ceedling 1.1.9 → 1.2.0

data/plugins/gcov/lib/reportgenerator_reportinator.rb

@@ -27,7 +27,7 @@ class ReportGeneratorReportinator < GcovReportinator
     @ceedling = system_objects
 
     # Validate the `reportgenerator` tool since it's used to generate reports
-    @ceedling[:tool_validator].validate( 
+    @ceedling[:tool_validator].validate(
       tool: TOOLS_GCOV_REPORTGENERATOR_REPORT,
       boom: true
     )
@@ -45,6 +45,7 @@ class ReportGeneratorReportinator < GcovReportinator
     @tool_executor = @ceedling[:tool_executor]
     @configurator  = @ceedling[:configurator]
     @batchinator   = @ceedling[:batchinator]
+    @file_wrapper  = @ceedling[:file_wrapper]
 
     # Mutex that serializes each gcov subprocess + rename pair (see run_gcov).
     @gcov_cwd_mutex = Mutex.new
@@ -97,7 +98,43 @@ class ReportGeneratorReportinator < GcovReportinator
     ReportTypes::XML_SUMMARY.upcase => "XmlSummary",
   }
 
-  REPORT_GENERATOR_SETTING_PREFIX = "gcov_report_generator"
+  REPORT_GENERATOR_SETTING_PREFIX = :gcov_report_generator
+
+  # Declarative map of the ReportGenerator options with a plain 1:1 flag mapping.
+  # :inline_value quotes flag and value together as a single CLI token (ReportGenerator's
+  # `-key:value` syntax), unlike gcovr's `--flag "value"` two-token style. A few options
+  # don't fit this 1:1 shape at all (createSubdirectoryForAllReportTypes is driven by
+  # report count, not a config option; the two numberOfReports*InParallel settings both
+  # derive from one :num_parallel_threads option) -- those stay explicit in
+  # build_optional_args below rather than being forced into this table.
+  REPORT_GENERATOR_COMMON_ARGS = {
+    :history_directory => { type: :inline_value, flag: '-historydir:' },
+    :plugins            => { type: :inline_value, flag: '-plugins:' },
+    :assembly_filters    => { type: :inline_value, flag: '-assemblyfilters:' },
+    :class_filters        => { type: :inline_value, flag: '-classfilters:' },
+    :verbosity            => { type: :inline_value, flag: '-verbosity:' },
+    :tag                  => { type: :inline_value, flag: '-tag:' },
+  }.freeze
+
+  # ReportGenerator's own analogue of gcovr's :fail_under_* family
+  # (minimumCoverageThresholds:*, added ReportGenerator v5.1.23) -- same naming
+  # convention and 1-100 validation as the gcovr side. Unlike gcovr's composite
+  # bit-flagged exit code, a threshold violation here is just an ordinary non-zero
+  # ReportGenerator exit -- run_reportgenerator already leaves :boom at its default
+  # (true), so any violation already raises and is already caught by
+  # Gcov#generate_coverage_reports's per-reportinator exception isolation.
+  #
+  # NOTE: like `settings:` above, `minimumCoverageThresholds:` takes NO leading `-`
+  # -- confirmed directly against a real `reportgenerator` run (`-minimumCoverage...`
+  # logs "Unknown command line parameter 'minimumCoverageThresholds'"; the dash-less
+  # form is accepted). Caught by that same Docker verification before this shipped,
+  # not after.
+  REPORT_GENERATOR_THRESHOLD_ARGS = {
+    :fail_under_line        => { type: :inline_integer_percent, flag: 'minimumCoverageThresholds:lineCoverage=' },
+    :fail_under_branch      => { type: :inline_integer_percent, flag: 'minimumCoverageThresholds:branchCoverage=' },
+    :fail_under_method      => { type: :inline_integer_percent, flag: 'minimumCoverageThresholds:methodCoverage=' },
+    :fail_under_full_method => { type: :inline_integer_percent, flag: 'minimumCoverageThresholds:fullMethodCoverage=' },
+  }.freeze
 
   # Map configured report types to ReportGenerator names, silently skipping unknowns.
   # Returns an array used to build both the -reporttypes: value and the report count.
@@ -108,29 +145,34 @@ class ReportGeneratorReportinator < GcovReportinator
 
   # Build the optional ${6} argument string for ReportGenerator.
   # report_type_count drives the createSubdirectoryForAllReportTypes setting.
+  #
+  # NOTE: unlike every other option in this method, ReportGenerator's `settings:` keys
+  # take NO leading `-` -- confirmed directly against a real `reportgenerator` run
+  # (`-settings:...` logs "Unknown command line parameter 'settings'" and the setting
+  # never applies; bare `settings:...` is accepted and the resolved Settings JSON
+  # reflects it). This was mistakenly "fixed" once during this pass by matching the
+  # dash convention every sibling option uses, then caught and reverted by that same
+  # Docker verification -- left exactly as originally written, on purpose.
   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 += "\"-verbosity:#{rg_opts[:verbosity]}\" " unless rg_opts[:verbosity].nil?
-    args += "\"-tag:#{rg_opts[:tag]}\" " unless rg_opts[:tag].nil?
+    args = build_args_from_table(rg_opts, REPORT_GENERATOR_COMMON_ARGS)
+    args += build_args_from_table(rg_opts, REPORT_GENERATOR_THRESHOLD_ARGS, component_prefix: ':gcov ↳ :report_generator')
+
     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?
-    rg_opts[:custom_args].each do |custom_arg|
-      args += "\"#{custom_arg}\" " unless custom_arg.nil? || custom_arg.empty?
+    unless rg_opts[:num_parallel_threads].nil?
+      args += "\"settings:numberOfReportsParsedInParallel=#{rg_opts[:num_parallel_threads]}\" "
+      args += "\"settings:numberOfReportsMergedInParallel=#{rg_opts[:num_parallel_threads]}\" "
     end
+
+    args += build_custom_args(rg_opts[:custom_args])
     args.strip
   end
 
 
   # Get the ReportGenerator options from the project options.
   def collect_reportgenerator_opts(opts)
-    # dup prevents repeated calls from accumulating mutations on the shared opts hash --
-    # mirrors GcovrReportinator#collect_gcovr_opts' identical guard and rationale.
-    _opts = opts[REPORT_GENERATOR_SETTING_PREFIX.to_sym].dup
+    # dup prevents repeated calls from accumulating mutations on the shared opts hash,
+    # mirroring GcovrReportinator#collect_gcovr_opts' identical guard and rationale.
+    _opts = opts[REPORT_GENERATOR_SETTING_PREFIX].dup
 
     # Auto-generate -filefilters: exclusion patterns for test paths and the build root.
     # These exclude test files and all generated/framework files from coverage reports.
@@ -166,10 +208,11 @@ class ReportGeneratorReportinator < GcovReportinator
   # combining user-specified patterns with internally-generated ones.
   # Returns nil when empty.
   def build_gcno_exclude_regex(rg_opts)
+    data = build_exclusion_data
     gcno_exclusions = []
 
     # Collect user-specified coverage results exclusions.
-    for gcno_exclude_expression in rg_opts[:gcov_exclude]
+    rg_opts[:gcov_exclude].each do |gcno_exclude_expression|
       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 —
@@ -181,16 +224,35 @@ class ReportGeneratorReportinator < GcovReportinator
       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()
+    # Auto-generated exclusions: test files, matched anywhere a real basename could
+    # appear. Mocks/runners/framework files are handled separately below, scoped to
+    # :build_root -- see build_gcno_exclusions.
+    auto = build_gcno_exclusions()
+    gcno_exclusions += auto[:basename]
+
+    patterns = []
+
+    # User excludes + test_prefix. (\/|\\\\) 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. User patterns are
+    # intentionally not build-root-scoped -- a user may legitimately want to exclude
+    # arbitrary paths anywhere in the tree.
+    unless gcno_exclusions.empty?
+      patterns << "(\/|\\\\)(#{gcno_exclusions.join('|')})\\#{EXTENSION_GCNO}"
+    end
+
+    # Mock/runner/framework fragments additionally require a :build_root path-segment
+    # ancestor, since that's the only place these files are ever actually generated.
+    # (^|[\/\\]) requires build_root to be a real path segment (not e.g. 'rebuild');
+    # '.*' allows any subdirectory depth below build_root before the final
+    # separator+basename.
+    unless auto[:build_root_scoped].empty?
+      build_root = Regexp.escape(strip_leading_dot_slash(data[:build_root].to_s))
+      patterns << "(^|[\/\\\\])#{build_root}[\/\\\\].*[\/\\\\](#{auto[:build_root_scoped].join('|')})\\#{EXTENSION_GCNO}"
+    end
 
-    # 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}")
+    # nil when both buckets are empty so callers can skip the regex check entirely.
+    patterns.empty? ? nil : Regexp.new(patterns.map { |p| "(?:#{p})" }.join('|'))
   end
 
 
@@ -205,7 +267,7 @@ class ReportGeneratorReportinator < GcovReportinator
     # (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}"))
+    gcno_dirs = @file_wrapper.directory_listing(File.join(GCOV_BUILD_OUTPUT_PATH, "**", "*#{EXTENSION_GCNO}"))
       .map { |f| File.dirname(f) }
       .uniq
       .sort
@@ -213,7 +275,7 @@ class ReportGeneratorReportinator < GcovReportinator
     # 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}"))
+      files = @file_wrapper.directory_listing(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
@@ -236,7 +298,7 @@ class ReportGeneratorReportinator < GcovReportinator
   # 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
+    unless @file_wrapper.directory_listing(File.join(GCOV_BUILD_OUTPUT_PATH, "**", "*#{EXTENSION_GCOV}")).length > 0
       @loginator.log( "No matching .gcno coverage files found", Verbosity::COMPLAIN )
       return nil
     end
@@ -250,9 +312,9 @@ class ReportGeneratorReportinator < GcovReportinator
       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 
+      # 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: 
+      rg_opts[:file_filters],                                 # ${5} -filefilters:
       build_optional_args(rg_opts, report_type_names.length)  # ${6} optional args
     )
 
@@ -274,9 +336,21 @@ class ReportGeneratorReportinator < GcovReportinator
   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).
+  # Build filename-fragment patterns for the .gcno scan exclusion regex, split into two
+  # buckets by how they must be anchored:
+  #  - :basename           — test_prefix identifies a file by its own basename anywhere
+  #    it may appear; already basename-anchored by the caller's enclosing
+  #    "(\/|\\\\)...[^\/\\]*\.gcno" structure, no further scoping needed.
+  #  - :build_root_scoped  — mock/runner/framework fragments identify files Ceedling
+  #    itself generates exclusively under :build_root (mocks: configurator.rb
+  #    populate_cmock_defaults; runners: configurator_builder.rb
+  #    project_test_runners_path), so the caller additionally requires a :build_root
+  #    path-segment ancestor for these -- their own fragments have no word boundary or
+  #    other anchor within the basename itself.
+  # .gcno basenames are simple (e.g. 'test_foo.gcno', not 'test_foo.c.gcno') -- confirmed
+  # via form_test_object_filepath and Ruby's String#ext, which replaces rather than
+  # appends the extension. [^\/\\]* exists to tolerate whatever characters follow the
+  # prefix within the basename, not to skip an embedded source extension.
   # test_prefix/mock_prefix are config-driven, so they're Regexp-escaped -- unescaped, a
   # metacharacter in either (e.g. a literal '.') would silently over- or under-match.
   def build_gcno_exclusions
@@ -284,13 +358,17 @@ class ReportGeneratorReportinator < GcovReportinator
     # 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.
-    [
-      "#{Regexp.escape(data[:test_prefix].to_s)}[^\\/\\\\]*",  # test_foo.gcno
-      "#{Regexp.escape(data[:mock_prefix].to_s)}[^\\/\\\\]*",  # MockBar.gcno
-      "[^\\/\\\\]*_runner[^\\/\\\\]*",                          # test_foo_runner.gcno
-      Regexp.escape(File.basename(UNITY_C_FILE, '.*')),        # unity.gcno
-      Regexp.escape(File.basename(CMOCK_C_FILE, '.*'))         # cmock.gcno
-    ]
+    {
+      basename: [
+        "#{Regexp.escape(data[:test_prefix].to_s)}[^\\/\\\\]*"   # test_foo.gcno
+      ],
+      build_root_scoped: [
+        "#{Regexp.escape(data[:mock_prefix].to_s)}[^\\/\\\\]*",  # MockBar.gcno
+        "[^\\/\\\\]*_runner[^\\/\\\\]*",                          # test_foo_runner.gcno
+        Regexp.escape(File.basename(UNITY_C_FILE, '.*')),        # unity.gcno
+        Regexp.escape(File.basename(CMOCK_C_FILE, '.*'))         # cmock.gcno
+      ]
+    }
   end
 
 
@@ -320,9 +398,9 @@ class ReportGeneratorReportinator < GcovReportinator
 
       shell_result = @tool_executor.exec( command )
 
-      if shell_result[:exit_code] != 0
+      if @tool_executor.failed?( shell_result )
         @loginator.log(
-          "gcov could not process #{gcno_filepath} (exit #{shell_result[:exit_code]})",
+          "gcov could not process #{gcno_filepath} (exit #{shell_result[:status]&.exitstatus})",
           Verbosity::COMPLAIN
         )
       end
@@ -342,7 +420,7 @@ class ReportGeneratorReportinator < GcovReportinator
         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
+        @file_wrapper.mv(gcov_file, dest) if @file_wrapper.exist?(gcov_file) && gcov_file != dest
       end
 
       return shell_result

data/plugins/module_generator/Rakefile

@@ -74,7 +74,7 @@ end
 def call_create(cmd)
   retval = `#{CEEDLING_CLI_EXEC} module:create[#{cmd}] 2>&1`
   puts retval # Debug logging
-  if retval.match? /Error/i
+  if retval.match?( /Error/i )
     raise "Received error when creating:\n#{retval}"
   else
     puts "Created #{cmd}"
@@ -84,7 +84,7 @@ end
 def call_create_expecting_error(cmd)
   retval = `#{CEEDLING_CLI_EXEC} module:create[#{cmd}] 2>&1`
   puts retval # Debug logging
-  if retval.match? /Error/i
+  if retval.match?( /Error/i )
     puts "Received expected error when creating #{cmd}"
   else
     raise "Should have received error when creating #{cmd}"
@@ -94,7 +94,7 @@ end
 def call_destroy(cmd)
   retval = `#{CEEDLING_CLI_EXEC} module:destroy[#{cmd}] 2>&1`
   puts retval # Debug logging
-  if retval.match? /Error/i
+  if retval.match?( /Error/i )
     raise "Received error when destroying:\n#{retval}"
   else
     puts "Destroyed #{cmd}"
@@ -104,7 +104,7 @@ end
 def call_stub(cmd)
   retval = `#{CEEDLING_CLI_EXEC} module:stub[#{cmd}] 2>&1`
   puts retval # Debug logging
-  if retval.match? /Error/i
+  if retval.match?( /Error/i )
     raise "Received error when stubbing:\n#{retval}"
   else
     puts "Stubbed #{cmd}"

data/plugins/module_generator/config/module_generator.yml

@@ -6,7 +6,6 @@
 # =========================================================================
 
 :module_generator:
-  :naming: :snake #options: :bumpy, :camel, :caps, or :snake
   :boilerplates: 
     :src: ""
     :inc: ""

data/plugins/module_generator/example/project.yml

@@ -154,7 +154,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/module_generator/lib/module_generator.rb

@@ -6,117 +6,147 @@
 # =========================================================================
 
 require 'ceedling/plugins/plugin'
+require 'ceedling/exceptions'
 require 'ceedling/constants'
-require 'erb'
-require 'fileutils'
-
+require 'module_generator_request'
+require 'module_generator_options'
+require 'module_generator_project'
+require 'module_generator_test_file'
+
+# Creates, destroys, stubs, and tests modules for the `module:` tasks. Unity's module
+# generator, through ModuleGeneratorUnity, writes and removes source, header, and test
+# files, and CMock's skeleton generator writes a source file of stubs from a header. This
+# plugin hands each one the options ModuleGeneratorOptions builds for a request from the
+# project configuration.
 class ModuleGenerator < Plugin
 
-  attr_reader :config, :interactionizer
+  # The configured test file prefix, which marks a module argument as a test file
+  def test_prefix
+    return @ceedling[:configurator].project_config_hash[:project_test_file_prefix]
+  end
 
-  def create(module_name, optz={})
+  def create(request)
+    generator = unity_generator( request )
+    planned   = generator.files_to_operate_on( request.name )
+    warn_same_named( planned )
+    generator.generate( request.name )
+    warn_undefined_test_define( planned.reject { |file| file[:test_define].nil? }.map { |file| file[:path].to_s } )
+  end
 
-    # grab our own reference to the main configuration hash
-    @project_config = @ceedling[:configurator].project_config_hash
+  def destroy(request)
+    unity_generator( request ).destroy( request.name )
+  end
 
-    # load the generate module script form Unity's collection of scripts.
-    require "generate_module.rb" 
+  def stub(request)
+    require 'cmock'
 
-    # if asked to destroy, do so. otherwise create (because isn't creating something always better?)
-    if ((!optz.nil?) && (optz[:destroy]))
-      UnityModuleGenerator.new( divine_options(optz) ).destroy(module_name)
-    else
-      UnityModuleGenerator.new( divine_options(optz) ).generate(module_name)
-    end
+    stub = options.stub( request )
+    CMock.new( stub[:cmock] ).setup_skeletons( stub[:header] )
   end
 
-  def stub_from_header(module_name, optz={})
-
-    # grab our own reference to the main configuration hash
-    @project_config = @ceedling[:configurator].project_config_hash
+  # Writes a test file with an ignored test for each function the module's header
+  # declares, or adds tests for newly declared functions to an existing one
+  def test(request)
+    require 'cmock'
 
-    # load CMock to be used for stubbing here.
-    require "cmock.rb"
+    test      = options.test( request )
+    functions = header_functions( test )
+    existing  = @ceedling[:file_wrapper].exist?( test[:path] ) ? @ceedling[:file_wrapper].read( test[:path] ) : nil
+    result    = ModuleGeneratorTestFile.new( **test[:file] ).render( functions, existing: existing )
 
-    # generate skeleton file
-    stuboptz = divine_options(optz)
-    stuboptz[:subdir] = nil
-    stuboptz[:mock_path] = stuboptz[:path_src]
-    filename = File.join(stuboptz[:path_inc], module_name + ".h")
-    puts stuboptz.to_yaml
-    CMock.new(stuboptz).setup_skeletons(filename)
+    write_test( test[:path], result, existing.nil? )
+    warn_undefined_test_define( [test[:path]] )
   end
 
   private
 
-  def divine_options(optz={})
-    # Build default configuration based on looking up other values
-    unity_generator_options =
-    {
-      :pattern      => optz[:pattern],
-      :test_prefix  => ((defined? PROJECT_TEST_FILE_PREFIX     ) ? PROJECT_TEST_FILE_PREFIX : "Test" ),
-      :mock_prefix  => ((defined? CMOCK_MOCK_PREFIX            ) ? CMOCK_MOCK_PREFIX : "Mock" ),
-      :includes     => ((defined? MODULE_GENERATOR_INCLUDES    ) ? MODULE_GENERATOR_INCLUDES : {} ),
-      :boilerplates => ((defined? MODULE_GENERATOR_BOILERPLATES) ? MODULE_GENERATOR_BOILERPLATES : {} ),
-      :naming       => ((defined? MODULE_GENERATOR_NAMING      ) ? MODULE_GENERATOR_NAMING : nil ),
-      :update_svn   => ((defined? MODULE_GENERATOR_UPDATE_SVN  ) ? MODULE_GENERATOR_UPDATE_SVN : false ),
-      :test_define  => ((defined? MODULE_GENERATOR_TEST_DEFINE ) ? MODULE_GENERATOR_TEST_DEFINE : "TEST" ),
-      :path_src     => ((defined? MODULE_GENERATOR_PATH_SRC    ) ? MODULE_GENERATOR_PATH_SRC : nil ),
-      :path_inc     => ((defined? MODULE_GENERATOR_PATH_INC    ) ? MODULE_GENERATOR_PATH_INC : nil ),
-      :path_tst     => ((defined? MODULE_GENERATOR_PATH_TST    ) ? MODULE_GENERATOR_PATH_TST : nil ),
-    }
-
-    # Add our lookup paths to this, based on overall project configuration
-    unity_generator_options[:paths_src] = @project_config[:collection_paths_source]  || [ 'src' ]
-    unity_generator_options[:paths_inc] = @project_config[:collection_paths_include] || @project_config[:collection_paths_source] || [ 'src' ]
-    unity_generator_options[:paths_tst] = @project_config[:collection_paths_test]    || [ 'test' ]
-
-    # Flatten if necessary
-    if (unity_generator_options[:paths_src].class == Hash)
-      unity_generator_options[:paths_src] = unity_generator_options[:paths_src].values.flatten
-    end
-    if (unity_generator_options[:paths_inc].class == Hash)
-      unity_generator_options[:paths_inc] = unity_generator_options[:paths_inc].values.flatten
-    end
-    if (unity_generator_options[:paths_tst].class == Hash)
-      unity_generator_options[:paths_tst] = unity_generator_options[:paths_tst].values.flatten
-    end
+  def header_functions(test)
+    source = @ceedling[:file_wrapper].read( test[:header] )
+    parsed = CMockHeaderParser.new( CMockConfig.new( test[:cmock] ) ).parse( test[:file][:module_name], source )
+
+    return parsed[:functions].map { |function| function[:name] }
+  rescue SystemCallError
+    raise CeedlingException.new( "Module header `#{test[:header]}` does not exist." )
+  end
+
+  def write_test(path, result, created)
+    return @ceedling[:loginator].log( "No new functions to test in #{path}" ) if !created and result.added.empty?
 
-    # Read Boilerplate template file.
-    if (defined? MODULE_GENERATOR_BOILERPLATE_FILES)
+    @ceedling[:file_wrapper].mkdir( File.dirname( path ) )
+    @ceedling[:file_wrapper].write( path, result.content )
+    @ceedling[:loginator].log( "#{created ? 'Created' : 'Updated'} #{path} with #{result.added.size} test(s)" )
+  end
+
+  def unity_generator(request)
+    require 'module_generator_unity'
+
+    return ModuleGeneratorUnity.new( options.unity( request ) )
+  end
+
+  # Built once per run from configuration that does not change during it
+  def options
+    return @options if @options
+
+    warn_update_svn
+    @options = ModuleGeneratorOptions.new(
+      config:             @ceedling[:configurator].project_config_hash,
+      cmock_config:       @ceedling[:configurator].get_cmock_config,
+      path_finder:        method( :find_path ),
+      boilerplate_reader: method( :read_boilerplate )
+    )
+  end
 
-      bf = MODULE_GENERATOR_BOILERPLATE_FILES
+  def project
+    return @project ||= ModuleGeneratorProject.new(
+      @ceedling[:configurator].project_config_hash,
+      test_defines: ->( path ) { @ceedling[:defineinator].defines( subkey: :test, filepath: path ) }
+    )
+  end
 
-      if !bf[:src].nil? && File.exist?(bf[:src])
-        unity_generator_options[:boilerplates][:src] = File.read(bf[:src])
-      end
+  # Subversion support is gone, so a configured :update_svn is noted, once with the
+  # options, and ignored
+  def warn_update_svn
+    return unless @ceedling[:configurator].project_config_hash.key?( :module_generator_update_svn )
 
-      if !bf[:inc].nil? && File.exist?(bf[:inc])
-        unity_generator_options[:boilerplates][:inc] = File.read(bf[:inc])
-      end
+    @ceedling[:loginator].log(
+      'Module Generator :update_svn is deprecated and ignored. Add generated files to source control with your own tools.',
+      Verbosity::COMPLAIN, LogLabels::WARNING
+    )
+  end
 
-      if !bf[:tst].nil? && File.exist?(bf[:tst])
-        unity_generator_options[:boilerplates][:tst] = File.read(bf[:tst])
-      end
+  # A same-named file elsewhere is allowed, but worth knowing about before it exists
+  def warn_same_named(files)
+    project.same_named( files.map { |file| file[:path].to_s } ).each do |planned, existing|
+      @ceedling[:loginator].log(
+        "Module file `#{planned}` shares its name with #{existing.map { |path| "`#{path}`" }.join( ', ' )}.",
+        Verbosity::COMPLAIN, LogLabels::WARNING
+      )
     end
+  end
 
-    # Check if using "create[<module_root>:<module_name>]" optional paths from command line.
-    if optz[:module_root_path].to_s.empty?
-      # No path specified. Use the one specified in the module generator section if it exists, 
-      # else the first of each list because we have nothing else to base it on
-      unity_generator_options[:skeleton_path] ||= unity_generator_options[:paths_src][0]
-      unity_generator_options[:path_src] ||= unity_generator_options[:paths_src][0]
-      unity_generator_options[:path_inc] ||= unity_generator_options[:paths_inc][0]
-      unity_generator_options[:path_tst] ||= unity_generator_options[:paths_tst][0]
-    else
-      # A path was specified. Do our best to determine which is the best choice based on this information
-      unity_generator_options[:path_src] = @ceedling[:file_finder_helper].find_best_path_in_collection(optz[:module_root_path], unity_generator_options[:paths_src], :error, 'source')  || unity_generator_options[:paths_src][0]
-      unity_generator_options[:path_inc] = @ceedling[:file_finder_helper].find_best_path_in_collection(optz[:module_root_path], unity_generator_options[:paths_inc], :error, 'include') || unity_generator_options[:paths_inc][0]
-      unity_generator_options[:path_tst] = @ceedling[:file_finder_helper].find_best_path_in_collection(optz[:module_root_path], unity_generator_options[:paths_tst], :error, 'test')    || unity_generator_options[:paths_tst][0]
-      unity_generator_options[:skeleton_path] = unity_generator_options[:path_src]
+  # A test file whose build lacks its guard symbol compiles to nothing. Per-test matchers
+  # can give each test file different defines, so each is checked on its own.
+  def warn_undefined_test_define(test_paths)
+    define = options.test_define
+
+    test_paths.reject { |path| project.test_defined?( define, path ) }.each do |path|
+      @ceedling[:loginator].log(
+        "Generated test `#{path}` is wrapped in `##{options.test_guard} #{define}`, but its build does not " \
+        "define #{define}. Add it under :defines ↳ :test, or the test compiles to nothing.",
+        Verbosity::COMPLAIN, LogLabels::WARNING
+      )
     end
+  end
+
+  # The path in a list a hint matches best, or nil when it matches none
+  def find_path(hint, paths)
+    return @ceedling[:file_finder_helper].find_best_path_in_collection( hint, paths, :error, 'module' )
+  rescue CeedlingException
+    return nil
+  end
 
-    return unity_generator_options
+  def read_boilerplate(path)
+    return @ceedling[:file_wrapper].exist?( path ) ? @ceedling[:file_wrapper].read( path ) : nil
   end
 
 end