ceedling 1.0.1 → 1.1.0

data/bin/mixin_standardizer.rb

@@ -0,0 +1,127 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class MixinStandardizer
+
+  constructor :reportinator
+
+  def setup
+    # ...
+  end
+
+  def smart_standardize(config:, mixin:, notices:)
+    modified = false
+    modified |= smart_standardize_defines(config, mixin, notices)
+    modified |= smart_standardize_flags(config, mixin, notices)
+    return modified
+  end
+
+  ### Private
+
+  private
+
+  def smart_standardize_defines(config, mixin, notices)
+    modified = false
+    
+    # Bail out if config and mixin do noth both have :defines
+    return false unless config[:defines] && mixin[:defines]
+    
+    # Iterate over :defines ↳ <context> keys
+    # If both config and mixin contain the same key paths, process their (matcher) values
+    config[:defines].each do |context, context_hash|
+      if mixin[:defines][context]
+
+        # Standardize :defines ↳ <context> matcher conventions if they differ so they can be merged later
+        standardized, notice = standardize_matchers(
+          config[:defines][context],
+          mixin[:defines][context],
+          config[:defines],
+          mixin[:defines],
+          context
+        )
+
+        if standardized
+          path, _ = @reportinator.generate_config_walk( [:defines, context] )
+          _notice = "At #{path}: #{notice}"
+          notices.push( _notice )
+        end
+
+        modified |= standardized
+      end
+    end
+    
+    return modified
+  end
+
+  def smart_standardize_flags(config, mixin, notices)
+    modified = false
+    
+    # Bail out if config and mixin do noth both have :flags
+    return false unless config[:flags] && mixin[:flags]
+    
+    # Iterate over :flags ↳ <context> ↳ <operation> keys
+    # If both config and mixin contain the same key paths, process their (matcher) values
+    config[:flags].each do |context, context_hash|
+      next unless mixin[:flags][context]
+      
+      context_hash.each do |operation, operation_hash|
+        if mixin[:flags][context][operation]
+
+          # Standardize :flags ↳ <context> ↳ <operation> matcher conventions if they differ so they can be merged later
+          standardized, notice = standardize_matchers(
+            config[:flags][context][operation],
+            mixin[:flags][context][operation],
+            config[:flags][context],
+            mixin[:flags][context],
+            operation
+          )
+
+          if standardized
+            path, _ = @reportinator.generate_config_walk( [:flags, context, operation] )
+            _notice = "At #{path}: #{notice}"
+            notices.push( _notice )
+          end
+
+          modified |= standardized
+        end
+      end
+    end
+    
+    return modified
+  end
+
+  def standardize_matchers(config_value, mixin_value, config_parent, mixin_parent, key)
+    # If both values are the same type, do nothing
+    return false, nil if (config_value.class == mixin_value.class)
+
+    # Promote mixin value list to all-matches matcher hash
+    if config_value.is_a?(Hash) && mixin_value.is_a?(Array)
+      # Ensure all-matches matcher key is a symbol and not a string
+      if (deleted = config_value.delete( '*' ))
+        config_value[:*] = deleted
+      end
+
+      # Replace the value of a simple array list with a matcher hash that stores the original list
+      mixin_parent[key] = {:* => mixin_value}
+      return true, 'Converted mixin list to matcher hash to facilitate merging with configuration'
+    end
+
+    # Promote config value list to all-matches matcher hash
+    if config_value.is_a?(Array) && mixin_value.is_a?(Hash)
+      # Ensure all-matches matcher key is a symbol and not a string
+      if (deleted = mixin_value.delete( '*' ))
+        mixin_value[:*] = deleted
+      end
+
+      # Replace the value of a simple array list with a matcher hash that stores the original list
+      config_parent[key] = {:* => config_value}
+      return true, 'Converted configuration list to matcher hash to facilitate merging with mixin'
+    end
+    
+    return false, nil
+  end
+end

data/bin/mixinator.rb

@@ -1,18 +1,19 @@
 # =========================================================================
 #   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 'deep_merge'
+require 'ceedling/exceptions'
 
 class Mixinator
 
-  constructor :path_validator, :yaml_wrapper, :loginator
+  constructor :mixin_standardizer, :merginator, :path_validator, :yaml_wrapper, :loginator
 
   def setup
-    # ...
+    # Aliases
+    @standardinator = @mixin_standardizer
   end
 
   def validate_cmdline_filepaths(paths)
@@ -26,6 +27,44 @@ class Mixinator
     end
   end
 
+  def validate_cmdline_yaml_strings(yaml_strings)
+    # Validate a list of inline YAML strings from --mixin "=..." command line arguments.
+    # Errors are accumulated so the user sees all problems before the run aborts.
+    # Raises on any validation failure (mirrors validate_mixins behavior for file entries).
+    validated = true
+
+    yaml_strings.each_with_index do |str, idx|
+      label = "Inline YAML mixin ##{idx + 1}"  # 1-based, matches user's command line order
+
+      # Empty string means the user typed --mixin "=" with nothing after the sigil
+      if str.nil? || str.strip.empty?
+        @loginator.log( "#{label} is empty", Verbosity::ERRORS )
+        validated = false
+        next
+      end
+
+      begin
+        parsed = @yaml_wrapper.load_string( str, source_label: label )
+
+        # A Ceedling configuration must be a Hash at the top level; arrays and scalars
+        # cannot be merged into config and indicate a user error in the YAML string
+        unless parsed.is_a?( Hash )
+          @loginator.log(
+            "#{label} did not produce a configuration hash after parsing (got #{parsed.class})",
+            Verbosity::ERRORS
+          )
+          validated = false
+        end
+      rescue YamlLoadException => e
+        # YAML load failure: e.message already identifies the label and the underlying problem
+        @loginator.log( e.message, Verbosity::ERRORS )
+        validated = false
+      end
+    end
+
+    raise 'Command line --mixin inline YAML failed validation' unless validated
+  end
+
   def fetch_env_filepaths(env)
     var_names = []
 
@@ -71,66 +110,193 @@ class Mixinator
   end
 
   def assemble_mixins(config:, env:, cmdline:)
-    assembly = []
-
-    # Build list of hashses in precedence order to facilitate deduplication
-    # Any duplicates at greater indexes are removed
-    cmdline.each {|mixin| assembly << {'command line' => mixin}}
-    assembly += env
-    config.each {|mixin| assembly << {'project configuration' => mixin}}
-
-    # Remove duplicates inline
-    #  1. Expand filepaths to absolute paths for correct deduplication (skip expanding simple mixin names)
-    #  2. Remove duplicates
-    assembly.uniq! do |entry|
-      # If entry is filepath, expand it, otherwise leave entry untouched (it's a mixin name only)
+    # === Pass 1: Build combined list in deduplication-priority order ===
+    #
+    # uniq! (used below) keeps the first occurrence of each mixin and drops
+    # later duplicates. To give higher-priority sources the "winning" entry
+    # on a collision, we put them first in this pass:
+    #
+    #   1. Command line --mixin flags    (first → highest dedup priority)
+    #   2. CEEDLING_MIXIN_# env vars     (ascending numeric order)
+    #   3. Project configuration :enabled mixins (last → lowest dedup priority)
+    #
+    dedup = []
+    # cmdline entries are pre-tagged {source_label => value} hashes from configinator;
+    # they carry either 'command line' (file/builtin) or 'command line (inline)' (YAML string)
+    cmdline.each {|mixin| dedup << mixin}
+    dedup += env
+    # config entries arrive pre-built from configinator as {'project configuration' => path, :_input => name}
+    config.each  {|entry| dedup << entry}
+
+    # Remove duplicate mixins, keeping the highest-priority (first) occurrence.
+    # Filepaths are expanded to absolute paths so two relative paths that point
+    # to the same file are recognised as duplicates even if written differently.
+    # Simple mixin names (no path separators or extension) are compared as-is.
+    dedup.uniq! do |entry|
       mixin = entry.values.first
       @path_validator.filepath?( mixin ) ? File.expand_path( mixin ) : mixin
     end
 
-    # Return the compacted list in merge order
-    #  1. Config
-    #  2. Environment variable
-    #  3. Command line
-    # Later merges take precedence (e.g. command line mixins are last merge)
-    return assembly.reverse()
+    # === Pass 2: Re-partition into merge order ===
+    #
+    # Re-group the deduplicated entries by source (preserving within-group
+    # order), then concatenate in lowest-to-highest-priority order so that the
+    # later (higher-priority) merges win single-value conflicts and so that
+    # higher-priority list entries are prepended to appear first:
+    #
+    #   1. Project configuration :enabled mixins  (merged first — lowest priority)
+    #   2. CEEDLING_MIXIN_# environment variables  (ascending numeric order)
+    #   3. Command line --mixin flags              (merged last — highest priority)
+    #
+    config_entries  = dedup.select {|e| e.keys.first == 'project configuration'}
+    env_entries     = dedup.select {|e| e.keys.first.start_with?('CEEDLING_MIXIN_')}
+    # Include both 'command line' (file/builtin) and 'command line (inline)' (YAML string) entries;
+    # relative order within this group is preserved from Pass 1 (original left-to-right cmdline order)
+    cmdline_entries = dedup.select {|e| e.keys.first.start_with?('command line')}
+
+    return config_entries + env_entries + cmdline_entries
   end
 
-  def merge(builtins:, config:, mixins:)
+  def mixin(builtins:, config:, mixins:)
     mixins.each do |mixin|
       source = mixin.keys.first
       filepath = mixin.values.first
 
       _mixin = {} # Empty initial value
 
+      # Dispatch on source label to select the appropriate load strategy.
+      # Inline YAML entries carry source label 'command line (inline)' and hold the raw
+      # YAML string in the filepath slot (named for the common case; dual-purposed here).
+      if source == 'command line (inline)'
+        # Inline YAML: parse the string directly instead of reading a file
+        begin
+          _mixin = @yaml_wrapper.load_string( filepath, source_label: 'command line inline YAML mixin' )
+        rescue YamlLoadException => e
+          raise YamlLoadException.new(
+            reason: e.reason, source: e.source, original_error: e.original_error,
+            message: "Command line inline YAML mixin failed to load ⏩️ #{e.message}"
+          )
+        end
+        @loginator.lazy( Verbosity::OBNOXIOUS ) { " + Merging command line inline YAML mixin" }
+
       # Load mixin from filepath if it is a filepath
-      if @path_validator.filepath?( filepath )
-        _mixin = @yaml_wrapper.load( filepath )
+      elsif @path_validator.filepath?( filepath )
+        begin
+          _mixin = @yaml_wrapper.load( filepath )
+        rescue YamlLoadException => e
+          raise YamlLoadException.new(
+            reason: e.reason, source: e.source, original_error: e.original_error,
+            message: "Mixin '#{filepath}' from #{source} failed to load ⏩️ #{e.message}"
+          )
+        end
 
         # Log what filepath we used for this mixin
-        @loginator.log( " + Merging #{'(empty) ' if _mixin.nil?}#{source} mixin using #{filepath}", Verbosity::OBNOXIOUS )
+        @loginator.lazy( Verbosity::OBNOXIOUS ) { " + Merging #{'(empty) ' if _mixin.nil?}#{source} mixin using #{filepath}" }
 
       # Reference mixin from built-in hash-based mixins
       else
         _mixin = builtins[filepath.to_sym()]
 
         # Log built-in mixin we used
-        @loginator.log( " + Merging built-in mixin '#{filepath}' from #{source}", Verbosity::OBNOXIOUS )
+        @loginator.lazy( Verbosity::OBNOXIOUS ) { " + Merging built-in mixin '#{filepath}' from #{source}" }
       end
 
       # Hnadle an empty mixin (it's unlikely but logically coherent and a good safety check)
       _mixin = {} if _mixin.nil?
 
-      # Sanitize the mixin config by removing any :mixins section (these should not end up in merges)
-      _mixin.delete(:mixins)
+      # Normalize String keys to Symbol keys: YAML flow mappings ({key: value}) produce
+      # String keys, but Ceedling config uses Symbol keys throughout. Converting here
+      # makes flow-style inline YAML merge correctly without requiring the invalid {: key:} syntax.
+      _mixin = deep_symbolize_keys( _mixin )
+
+      # Nested :mixins sections are not supported — warn and strip before merging
+      if _mixin.key?(:mixins)
+        msg = "Mixin from #{source} '#{filepath}' contains a `:mixins` section ➡️ Nested mixins are not supported and will be ignored."
+        @loginator.log( msg, Verbosity::COMPLAIN )
+        _mixin.delete(:mixins)
+      end
 
-      # Merge this bad boy
-      config.deep_merge( _mixin )
+      # Prevent mixin files from injecting their own :history entries
+      _mixin.delete(:history)
+
+      # Run special handling using knowledge of Ceedling configuration conventions
+      notices = []
+      if @standardinator.smart_standardize( config:config, mixin:_mixin, notices:notices )
+        notices.each { |msg| @loginator.log( msg, Verbosity::COMPLAIN, LogLabels::NOTICE ) }
+      end
+
+      warnings = []
+      if !@merginator.merge( config:config, mixin:_mixin, warnings:warnings )
+        msg = "Mixin values from #{filepath} will replace configuration values for incompatible merges..."
+        @loginator.log( msg, Verbosity::COMPLAIN, LogLabels::NOTICE )
+        warnings.each { |msg| @loginator.log( msg, Verbosity::COMPLAIN ) }
+      end
+
+      # Record this mixin in the configuration history as a structured hash.
+      # :_input carries the original user-provided value (before load-path resolution) for cmdline
+      # and config entries; env var entries use the filepath directly (it IS the original value).
+      input = mixin[:_input]
+
+      mechanism    = case source
+                     when 'command line', 'command line (inline)' then :cmdline
+                     when 'project configuration'                 then :config
+                     else                                              :env
+                     end
+      source_label = case source
+                     when 'command line', 'command line (inline)' then '--mixin'
+                     when 'project configuration'                 then ':enabled'
+                     else                                              source  # env var name as-is
+                     end
+
+      config[:history] ||= {}
+      config[:history][:config] ||= []
+
+      if source == 'command line (inline)'
+        # For inline YAML, the filepath slot holds the raw YAML string (see dispatch above)
+        config[:history][:config] << {
+          type:      :inline,
+          mechanism: :cmdline,
+          source:    source_label,
+          value:     filepath
+        }
+      else
+        config[:history][:config] << {
+          type:      :file,
+          path:      filepath,
+          mechanism: mechanism,
+          source:    source_label,
+          value:     input || filepath  # original user input if threaded; fall back to filepath
+        }
+      end
     end
 
     # Validate final configuration
+    # Exclude :history — it is internal bookkeeping added by this method and
+    # should not be counted as meaningful user configuration content.
     msg = "Final configuration is empty"
-    raise msg if config.empty?
+    raise msg if (config.keys - [:history]).empty?
+  end
+
+  private
+
+  # Recursively convert all String keys in a nested Hash/Array structure to Symbol keys.
+  # This normalizes YAML flow mappings ({key: value} → String keys) to match Ceedling's
+  # Symbol-keyed configuration ({:key => value}), enabling correct deep merging.
+  # Safe to call on Hash structures already using Symbol keys — it's a no-op for those.
+  def deep_symbolize_keys(obj)
+    case obj
+    when Hash
+      # Rebuild the hash with Symbol keys, recursing into values
+      obj.each_with_object({}) do |(k, v), memo|
+        memo[k.is_a?( String ) ? k.to_sym : k] = deep_symbolize_keys( v )
+      end
+    when Array
+      # Recurse into arrays in case they contain hashes (e.g. :tools sections)
+      obj.map { |el| deep_symbolize_keys( el ) }
+    else
+      # Scalars (strings, integers, booleans, nil) are returned unchanged
+      obj
+    end
   end
 
 end

data/bin/mixins.rb

@@ -1,12 +1,14 @@
 # =========================================================================
 #   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
 # =========================================================================
 
-
 BUILTIN_MIXINS = {
   # Mixin name as symbol => mixin config hash
   # :mixin => {}
 }
+
+_vendor = defined?(CEEDLING_APPCFG) ? CEEDLING_APPCFG[:ceedling_vendor_path] : File.expand_path( File.join( File.dirname(__FILE__), '..', 'vendor' ) )
+BUILTIN_MIXIN_LOAD_PATHS = [ File.join( _vendor, UNITY_ROOT_PATH, 'test', 'targets' ) ].freeze

data/bin/objects.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
 # =========================================================================
 
@@ -14,12 +14,18 @@ file_wrapper:
 
 yaml_wrapper:
 
+ruby_expandinator:
+
 config_walkinator:
 
 system_wrapper:
 
 verbosinator:
 
+reportinator:
+
+rake_task_registry:
+
 loginator:
   compose:
     - verbosinator
@@ -40,6 +46,7 @@ cli_handler:
     - projectinator
     - cli_helper
     - path_validator
+    - rake_task_registry
     - actions_wrapper
     - loginator
 
@@ -49,8 +56,11 @@ cli_helper:
     - config_walkinator
     - path_validator
     - actions_wrapper
+    - rake_task_registry
     - loginator
+    - reportinator
     - system_wrapper
+    - ruby_expandinator
 
 path_validator:
   compose:
@@ -59,10 +69,20 @@ path_validator:
 
 mixinator:
   compose:
+    - mixin_standardizer
+    - merginator
     - path_validator
     - yaml_wrapper
     - loginator
 
+mixin_standardizer:
+  compose:
+    - reportinator
+
+merginator:
+  compose:
+    - reportinator
+
 projectinator:
   compose:
     - file_wrapper
@@ -70,6 +90,7 @@ projectinator:
     - yaml_wrapper
     - loginator
     - system_wrapper
+    - ruby_expandinator
 
 configinator:
   compose:

data/bin/path_validator.rb

@@ -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/bin/projectinator.rb

@@ -1,11 +1,12 @@
 # =========================================================================
 #   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/constants' # From Ceedling application
+require 'ceedling/exceptions'
 
 class Projectinator
 
@@ -13,7 +14,7 @@ class Projectinator
   DEFAULT_PROJECT_FILEPATH = './' + DEFAULT_PROJECT_FILENAME
   DEFAULT_YAML_FILE_EXTENSION = '.yml'
 
-  constructor :file_wrapper, :path_validator, :yaml_wrapper, :loginator, :system_wrapper
+  constructor :file_wrapper, :path_validator, :yaml_wrapper, :loginator, :system_wrapper, :ruby_expandinator
 
   # Discovers project file path and loads configuration.
   # Precendence of attempts:
@@ -29,6 +30,7 @@ class Projectinator
       @path_validator.standardize_paths( filepath )
       _filepath = File.expand_path( filepath )
       config = load_and_log( _filepath, 'from command line argument', silent )
+      config[:history] = { config: [{type: :file, path: filepath, mechanism: :project}] }
       return _filepath, config
 
     # Next priority: environment variable
@@ -37,11 +39,12 @@ class Projectinator
       filepath = env[PROJECT_FILEPATH_ENV_VAR].dup()
       @path_validator.standardize_paths( filepath )
       _filepath = File.expand_path( filepath )
-      config = load_and_log( 
+      config = load_and_log(
         _filepath,
         "from environment variable `#{PROJECT_FILEPATH_ENV_VAR}`",
         silent
       )
+      config[:history] = { config: [{type: :file, path: filepath, mechanism: :project}] }
       return _filepath, config
 
     # Final option: default filepath
@@ -49,10 +52,10 @@ class Projectinator
       filepath = DEFAULT_PROJECT_FILEPATH
       _filepath = File.expand_path( filepath )
       config = load_and_log( _filepath, "from working directory", silent )
+      config[:history] = { config: [{type: :file, path: filepath, mechanism: :project}] }
       return _filepath, config
 
-    # If no user provided filepath and the default filepath does not exist,
-    # we have a big problem
+    # If no user-provided filepath and the default filepath does not exist, we have a big problem
     else
       raise "No project filepath provided and default #{DEFAULT_PROJECT_FILEPATH} not found"
     end
@@ -109,11 +112,11 @@ class Projectinator
 
     # Handle any inline Ruby string expansion
     load_paths.each do |load_path|
-      load_path.replace( @system_wrapper.module_eval( load_path ) ) if (load_path =~ PATTERNS::RUBY_STRING_REPLACEMENT)
+      load_path.replace( @ruby_expandinator.expand( load_path, source: ":mixins ↳ :load_paths" ) )
     end
 
     enabled.each do |mixin|
-      mixin.replace( @system_wrapper.module_eval( mixin ) ) if (mixin =~ PATTERNS::RUBY_STRING_REPLACEMENT)
+      mixin.replace( @ruby_expandinator.expand( mixin, source: ":mixins ↳ :enabled" ) )
     end
 
     # Remove the :mixins section of the configuration
@@ -221,22 +224,28 @@ class Projectinator
 
       # Log what the heck we loaded
       if !silent
-        msg  = "Loaded #{'(empty) ' if config.empty?}project configuration #{method}.\n"
-        msg += " > Using: #{filepath}\n"
-        msg += " > Working directory: #{Dir.pwd()}"
-
-        @loginator.log( msg, Verbosity::NORMAL, LogLabels::CONSTRUCT )
+        @loginator.lazy( Verbosity::NORMAL, LogLabels::CONSTRUCT ) do 
+          "Loaded #{'(empty) ' if config.empty?}project configuration #{method}.\n" +
+          " > Using: #{filepath}\n" +
+          " > Working directory: #{Dir.pwd()}"
+        end
       end
 
       return config
-    rescue Errno::ENOENT
-      # Handle special case of user-provided blank filepath
-      filepath = filepath.empty?() ? '<none>' : filepath
-      raise "Could not find project filepath #{filepath} #{method}"
-
-    rescue StandardError => e
-      # Catch-all error handling
-      raise "Error loading project filepath #{filepath} #{method}: #{e.message}"
+    rescue YamlLoadException => e
+      if e.reason == :not_found
+        # Handle special case of user-provided blank filepath
+        _filepath = filepath.empty?() ? '<none>' : filepath
+        raise YamlLoadException.new(
+          reason: e.reason, source: e.source, original_error: e.original_error,
+          message: "Could not find project filepath #{_filepath} #{method}"
+        )
+      else
+        raise YamlLoadException.new(
+          reason: e.reason, source: e.source, original_error: e.original_error,
+          message: "Error loading project filepath #{filepath} #{method} ⏩️ #{e.message}"
+        )
+      end
     end
 
   end

data/bin/rake_patches.rb

@@ -0,0 +1,31 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'rake'
+require 'stringio'
+
+module CaptureHelpOutput
+  def capture_display_tasks
+    original_stdout = $stdout
+    output_string = StringIO.new
+    $stdout = output_string
+    
+    begin
+      # Call the original method that writes directly to $stdout with printf()
+      display_tasks_and_comments
+    ensure
+      # This block will always execute, even if an exception occurs
+      $stdout = original_stdout
+    end
+
+    # Restore original stdout
+    $stdout = original_stdout
+    
+    # Return the captured output
+    output_string.string
+  end
+end