ceedling 1.1.8 → 1.1.10

data/lib/ceedling/generators/generator_partials.rb

@@ -21,7 +21,8 @@ class GeneratorPartials
       source_includes:,
       header_includes:,
       c_module:,
-      output_path:
+      output_path:,
+      include_guard: nil
     )
     source = @file_path_utils.form_partial_implementation_source_filename(name)
     header = @file_path_utils.form_partial_implementation_header_filename(name)
@@ -34,7 +35,10 @@ class GeneratorPartials
     # write, which would alter any line ending already present in that
     # content instead of passing it through unchanged.
     @file_wrapper.open(header_filepath, 'wb') do |file|
-      generate_header(file, header, header_includes, function_definitions, c_module, true)
+      generate_header(
+        file, header, header_includes, function_definitions, c_module,
+        include_variables: true, include_guard: include_guard
+      )
     end
 
     @file_wrapper.open(source_filepath, 'wb') do |file|
@@ -44,13 +48,16 @@ class GeneratorPartials
     return source_filepath
   end
 
-  def generate_interface(test:, name:, function_declarations:, includes:, c_module:, output_path:)
+  def generate_interface(test:, name:, function_declarations:, includes:, c_module:, output_path:, include_guard: nil)
     header = @file_path_utils.form_partial_interface_header_filename(name)
     filepath = File.join(output_path, header)
 
     # Binary mode: see generate_implementation above.
     @file_wrapper.open(filepath, 'wb') do |file|
-      generate_header(file, header, includes, function_declarations, c_module, false)
+      generate_header(
+        file, header, includes, function_declarations, c_module,
+        include_variables: false, include_guard: include_guard
+      )
     end
 
     return filepath
@@ -69,7 +76,7 @@ class GeneratorPartials
   # @param c_module [CExtractorTypes::CModule] Merged module with type_definitions/aggregate_definitions
   # @param output_path [String] Directory shared with the implementation and interface headers
   # @return [String, nil] The bare filename (for use as a sibling #include), or nil if nothing was generated
-  def generate_types(name:, c_module:, output_path:)
+  def generate_types(name:, c_module:, output_path:, includes: [], include_guard: nil)
     return nil if c_module.type_definitions.empty? && c_module.aggregate_definitions.empty?
 
     header = @file_path_utils.form_partial_types_header_filename(name)
@@ -78,8 +85,7 @@ class GeneratorPartials
     # Binary mode: see generate_implementation above.
     @file_wrapper.open(filepath, 'wb') do |file|
       guard = FileWrapper.generate_include_guard(header)
-      file << "#ifndef #{guard}\n"
-      file << "#define #{guard}\n\n"
+      emit_preamble( file, guard, include_guard, includes )
 
       anything_emitted = false
       pending_macros = []
@@ -88,7 +94,10 @@ class GeneratorPartials
         next unless item.is_a?(CExtractorTypes::CStatement)
 
         if c_module.macro_definitions.include?(item)
-          pending_macros << item
+          # The guard emitted above also arrives among the extracted macros, since the real
+          # header's own `#define` survives preprocessing. Carrying it a second time is legal
+          # but puts a pointless duplicate in every generated types header.
+          pending_macros << item unless guard_macro?(item, include_guard)
           next
         end
 
@@ -116,6 +125,38 @@ class GeneratorPartials
 
   private
 
+  # Everything above a generated header's own content: the file's include guard, the spoof of the
+  # real module header's guard, and the includes that header carries. Shared by all three
+  # generated headers, which open identically.
+  #
+  # The order of the last two is the whole point. A carried header can transitively reach the
+  # real module header, so the spoof has to be satisfied before any include is processed rather
+  # than after. And relocated content names things a generated file does not define, so without
+  # the includes it compiles only where something earlier in the translation unit happened to
+  # supply those names -- which is what made the types header's placement a conflict between two
+  # correct requirements rather than a choice.
+  def emit_preamble(io, guard, include_guard, includes)
+    io << "#ifndef #{guard}\n"
+    io << "#define #{guard}\n\n"
+
+    # A module header with no guard of its own supplies nothing to spoof.
+    io << "#define #{include_guard}\n\n" if include_guard
+
+    return if includes.empty?
+
+    includes.each { |include| io << "#{include}\n" }
+    io << "\n"
+  end
+
+  # Whether a macro statement is nothing but the definition of `include_guard`. Anchored so a
+  # macro whose name merely begins with the guard's name is never mistaken for it, and so a
+  # guard-named macro carrying an actual value is left alone.
+  def guard_macro?(item, include_guard)
+    return false if include_guard.nil?
+
+    item.text.match?(/\A\s*#\s*define\s+#{Regexp.escape( include_guard )}\s*\z/)
+  end
+
   # A typedef or a non-typedef struct/enum/union tag definition establishes a type; C treats
   # a second definition of the same type in one translation unit as a redefinition error even
   # when the two definitions are textually identical. A macro statement carries no such
@@ -159,17 +200,9 @@ class GeneratorPartials
   # @param function_list   [Array]  Pre-filtered Partials function objects (respond to :name and :signature)
   # @param c_module        [CExtractorTypes::CModule] Merged module with element_sequence
   # @param include_variables [Boolean] True for implementation header (emits extern vars); false for interface
-  def generate_header(io, name, includes, function_list, c_module, include_variables)
+  def generate_header(io, name, includes, function_list, c_module, include_variables:, include_guard: nil)
     guard = FileWrapper.generate_include_guard( name )
-
-    io << "#ifndef #{guard}\n"
-    io << "#define #{guard}\n\n"
-
-    includes.each do |include|
-      io << "#{include}\n"
-    end
-
-    io << "\n" if !includes.empty?
+    emit_preamble( io, guard, include_guard, includes )
 
     func_by_name = function_list.to_h { |f| [f.name, f] }
     emitted_funcs = {}
@@ -192,6 +225,9 @@ class GeneratorPartials
         # generate_types instead of here, so that content defines a type exactly once no
         # matter how many of a module's generated headers end up in the same test file.
         next if type_defining?(item, c_module)
+        # The spoof above already states this one deliberately; carrying it again would put a
+        # pointless duplicate in the file.
+        next if guard_macro?(item, include_guard)
         io << item.text << "\n"
         last_was_func = false
         anything_emitted = true

data/lib/ceedling/includes/includes.rb

@@ -254,8 +254,15 @@ class Includes
     return _includes
   end
 
+  # Ruby's sort/sort_by family does not guarantee a stable sort -- the relative order
+  # of elements a comparator treats as equal (every UserInclude here, all mapping to
+  # the same "1") is free to come out differently across Ruby versions and platforms.
+  # partition sidesteps the question entirely: it's a simple filter, not a comparator
+  # sort, so each group's own original relative order is preserved by definition, on
+  # every Ruby version and platform, with nothing to be unstable about.
   def self.sort!(includes)
-    includes.sort_by! { |include| include.is_a?(SystemInclude) ? 0 : 1 }
+    system, other = includes.partition { |include| include.is_a?(SystemInclude) }
+    includes.replace(system + other)
     return includes
   end
 end

data/lib/ceedling/objects.yml

@@ -383,6 +383,8 @@ partializer:
     - file_finder
     - c_extractor
     - file_path_utils
+    - preprocessinator_reconstructor
+    - file_wrapper
     - reportinator
     - loginator
 

data/lib/ceedling/partials/partializer.rb

@@ -14,12 +14,18 @@ require 'ceedling/c_extractor/c_extractor'
 require 'ceedling/c_extractor/c_extractor_constants'
 require 'ceedling/c_extractor/c_extractor_types'
 require 'ceedling/constants'
+require 'ceedling/encodinator'
 
 class Partializer
 
+  # Enough of a header to reach its include guard. The guard pair sits at the top of a header by
+  # construction, so a bounded read beats loading a large file to find it.
+  GUARD_SCAN_BYTES = 2048
+
   include Partials
 
-  constructor :partializer_helper, :file_finder, :c_extractor, :file_path_utils, :reportinator, :loginator
+  constructor :partializer_helper, :file_finder, :c_extractor, :file_path_utils,
+              :preprocessinator_reconstructor, :file_wrapper, :reportinator, :loginator
 
   def setup()
     # Alias
@@ -82,115 +88,89 @@ class Partializer
     return configs
   end
 
+  # When `test:` is provided, logs the resulting includes at OBNOXIOUS.
+  # Includes for the generated implementation header. This module's own header is replaced by
+  # the shared types header at its original list position; every other partialized module's
+  # include is dropped.
+  #
   # When `test:` is provided, logs the resulting includes at OBNOXIOUS.
   def remap_implementation_header_includes(name:, includes:, partials:, types_header: nil, test: nil)
-    _includes = includes.clone()
-
-    # Get list of all partialized module names
-    partialized_modules = partials.keys
-
-    # Remove includes for all partialized modules
-    # Remove our own orginal name as well
-    _includes = remove_matching_includes(
-      includes: _includes,
-      modules: ([name] + partialized_modules)
+    _remap_includes(
+      name:        name,
+      includes:    includes,
+      partials:    partials,
+      replacement: types_header,
+      others:      :drop,
+      noun:        'Header includes to inject for testable Partial',
+      test:        test
     )
-
-    # When this module has any typedefs or aggregate definitions, they live in a shared
-    # header generated once and included here rather than duplicated inline.
-    _includes << UserInclude.new(types_header) if types_header
-
-    # Remove any duplicates
-    Includes.sanitize!(_includes)
-
-    @loginator.log_list(
-      _includes,
-      "Header includes to inject for testable Partial #{test}::#{name}:",
-      Verbosity::OBNOXIOUS
-    ) if test
-
-    return _includes
   end
 
+  # Includes for the generated mockable interface header. Same treatment as the implementation
+  # header: both files carry the shared types header, which is how a module tested and mocked
+  # in one test file still gets exactly one definition of each of its types.
+  #
   # When `test:` is provided, logs the resulting includes at OBNOXIOUS.
-  def remap_implementation_source_includes(name:, includes:, partials:, test: nil)
-    _includes = includes.clone()
-
-    # Add implementation header
-    _includes << UserInclude.new(
-      @file_path_utils.form_partial_implementation_header_filename(name)
+  def remap_interface_header_includes(name:, includes:, partials:, types_header: nil, test: nil)
+    _remap_includes(
+      name:        name,
+      includes:    includes,
+      partials:    partials,
+      replacement: types_header,
+      others:      :drop,
+      noun:        'Header includes to inject for mockable Partial',
+      test:        test
     )
+  end
 
-    mockable_modules = []
-
-    partials.each do |_module, config|
-      # Remap mockable interface headers that will be injected into generated partial implementation
-      #
-      # Any real (non-nil) mock mode means this module has a generated mock interface header
-      # to redirect to -- PUBLIC/PRIVATE alone once covered every mode that existed, but DEDUCT
-      # (MOCK_PARTIAL_ALL_MODULE) and ACCUMULATE (MOCK_PARTIAL_MODULE) were added later without
-      # updating this check, so a module mocked via either of those was silently never
-      # redirected: its real header (and any static inline/static function bodies in it) stayed
-      # #include'd verbatim, compiling straight past the mock instead of being replaced by it.
-      if includes.any? { |include| include.filename.ext().downcase() == _module.downcase() }
-        if !config.mocks.type.nil?
-          # Insert mockable interface header from remapping of module name
-          _includes << UserInclude.new(
-            @file_path_utils.form_partial_interface_header_filename(_module)
-          )
-          # Remember the module for later removal of original header
-          mockable_modules << _module
-        end
-      end
-    end
-
-    # Remove the original module header now that it's remapped to mockable interface
-    # Remove our own orginal name as well
-    _includes = remove_matching_includes(
-      includes: _includes,
-      modules: ([name] + mockable_modules)
+  # Includes for the generated implementation source. This module's own header is replaced by
+  # the generated implementation header, which carries the types header internally. Another
+  # partialized module that is mocked is redirected to its generated interface header; one that
+  # is not mocked keeps its real header, which the generated code still needs.
+  #
+  # When `test:` is provided, logs the resulting includes at OBNOXIOUS.
+  def remap_implementation_source_includes(name:, includes:, partials:, test: nil)
+    _remap_includes(
+      name:        name,
+      includes:    includes,
+      partials:    partials,
+      replacement: @file_path_utils.form_partial_implementation_header_filename(name),
+      others:      :mock_or_keep,
+      noun:        'Source includes to inject for testable Partial',
+      test:        test
     )
-
-    # Remove any duplicates
-    Includes.sanitize!(_includes)
-
-    @loginator.log_list(
-      _includes,
-      "Source includes to inject for testable Partial #{test}::#{name}:",
-      Verbosity::OBNOXIOUS
-    ) if test
-
-    return _includes
   end
 
+  # Includes the shared types header carries so the extracted types resolve wherever that file
+  # lands. Nothing replaces this module's own header here -- the types header cannot include
+  # itself -- so it is simply dropped. Another partialized module is redirected to its generated
+  # interface header when mocked and dropped otherwise: its real header would reintroduce the
+  # very content that module's own Partial replaced.
+  #
   # When `test:` is provided, logs the resulting includes at OBNOXIOUS.
-  def remap_interface_header_includes(name:, includes:, partials:, types_header: nil, test: nil)
-    _includes = includes.clone()
-
-    # Get list of all partialized module names
-    partialized_modules = partials.keys
-
-    # Remove includes for all partialized modules
-    # Remove our own orginal name as well
-    _includes = remove_matching_includes(
-      includes: _includes,
-      modules: ([name] + partialized_modules)
+  def remap_types_header_includes(name:, includes:, partials:, test: nil)
+    _remap_includes(
+      name:        name,
+      includes:    includes,
+      partials:    partials,
+      replacement: nil,
+      others:      :mock_or_drop,
+      noun:        'Dependency includes to carry into the shared types header for Partial',
+      test:        test
     )
+  end
 
-    # When this module has any typedefs or aggregate definitions, they live in a shared
-    # header generated once and included here rather than duplicated inline.
-    _includes << UserInclude.new(types_header) if types_header
-
-    # Remove any duplicates
-    Includes.sanitize!(_includes)
-
-    @loginator.log_list(
-      _includes,
-      "Header includes to inject for mockable Partial #{test}::#{name}:",
-      Verbosity::OBNOXIOUS
-    ) if test
-
-    return _includes
+  # The include guard macro the module's real header defines, or nil when it has none.
+  #
+  # Read from the original header rather than from the reconstituted copy or from extracted
+  # macros. The reconstituted copy carries a synthetic guard that #sanitize strips, so neither is
+  # a dependable source. A nil return means the header guards itself some other way --
+  # `#pragma once` -- and offers no macro for a generated file to spoof.
+  def extract_module_include_guard(filepath)
+    return nil if filepath.nil?
+
+    text = @file_wrapper.read( filepath, GUARD_SCAN_BYTES ).clean_encoding
+    @preprocessinator_reconstructor.extract_include_guard( text )
   end
 
   # Extracts and combines C code contents from header and source files
@@ -452,6 +432,134 @@ class Partializer
     )
   end
 
+  # One body behind all four public remaps. Each differs only in what replaces this module's
+  # own header, what becomes of other partialized modules, and the noun it logs under -- the
+  # splice, the sanitize, and the logging are identical in every case.
+  #
+  # `others` selects the treatment of every OTHER partialized module in the same test file:
+  #   :drop         -- remove its include outright, with no substitute
+  #   :mock_or_keep -- redirect to its interface header when mocked, else leave its real header
+  #   :mock_or_drop -- redirect to its interface header when mocked, else drop it
+  def _remap_includes(name:, includes:, partials:, replacement:, others:, noun:, test: nil)
+    _includes = includes.clone()
+
+    # A nil replacement strips this module's own header and substitutes nothing.
+    _includes = splice_in_replacement( includes: _includes, name: name, replacement: replacement )
+
+    _includes =
+      case others
+      when :drop
+        remove_matching_includes( includes: _includes, modules: (partials.keys - [name]) )
+      when :mock_or_keep, :mock_or_drop
+        # The types header differs from the generated source in two ways at once, which is why
+        # both flags below read from one condition.
+        #
+        # It skips this module: the interface header includes the types header, so carrying the
+        # interface back in would fold that file's declarations into this one. The generated
+        # source needs the opposite -- a module tested and mocked in one test file keeps its
+        # public bodies in the implementation and the private declarations they call in the
+        # interface, so it needs both.
+        #
+        # And it drops an unmocked partialized dependency rather than keeping its real header,
+        # which would reintroduce content that module's own Partial replaced.
+        shared_types_header = ( others == :mock_or_drop )
+
+        _redirect_mocked_partials(
+          includes: _includes,
+          original: includes,
+          name: name,
+          partials: partials,
+          drop_unmocked: shared_types_header,
+          skip_self: shared_types_header
+        )
+      else
+        PartializerRuntime.raise_on_option( others )
+      end
+
+    # Remove any duplicates
+    Includes.sanitize!(_includes)
+
+    @loginator.log_list(
+      _includes,
+      "#{noun} #{test}::#{name}:",
+      Verbosity::OBNOXIOUS
+    ) if test
+
+    return _includes
+  end
+
+  # Appends the generated interface header for each mocked partialized module the original list
+  # named, then removes the real headers those replaced. `skip_self` decides whether the module
+  # being generated counts as one of them, which it does everywhere except the types header --
+  # see the call site.
+  #
+  # Mutates `includes`, which always arrives fresh from splice_in_replacement.
+  #
+  # Any real (non-nil) mock mode counts. PUBLIC/PRIVATE alone once covered every mode that
+  # existed, but DEDUCT (MOCK_PARTIAL_ALL_MODULE) and ACCUMULATE (MOCK_PARTIAL_MODULE) were
+  # added later without updating the check, so a module mocked via either was silently never
+  # redirected: its real header, and any static inline or static function bodies in it, stayed
+  # #include'd verbatim and compiled straight past the mock.
+  def _redirect_mocked_partials(includes:, original:, name:, partials:, drop_unmocked:, skip_self:)
+    retired = []
+
+    partials.each do |_module, config|
+      next if skip_self && _module == name
+      next unless original.any? { |include| include.filename.ext().downcase() == _module.downcase() }
+
+      if config.mocks.type.nil?
+        retired << _module if drop_unmocked
+      else
+        includes << UserInclude.new(
+          @file_path_utils.form_partial_interface_header_filename(_module)
+        )
+        retired << _module
+      end
+    end
+
+    remove_matching_includes( includes: includes, modules: retired )
+  end
+
+  # Swaps `name`'s own header include for `replacement` at that same list position,
+  # instead of stripping it out and appending the replacement at the very end.
+  #
+  # Both call sites' generated replacements (the shared types header; the generated
+  # implementation header, which itself carries the types header) spoof the real
+  # header's own include guard (a top-of-file `#define <ORIGINAL_GUARD>`) so that if the
+  # real header is *also* reached a second way -- e.g. a transitively-included,
+  # differently-named header that itself does a genuine `#include` of this module's
+  # real header -- the real header's guard is already
+  # tripped and its content (a second, conflicting copy of the same typedefs/structs)
+  # never gets processed. That only works if the spoofing macro is defined *before*
+  # such a transitive re-inclusion is reached, not after. Appending at the very end put
+  # it after any such re-inclusion instead of before it. Keeping the replacement at the
+  # original header's own list position preserves everything the generated content
+  # depends on that came before it in the source's own working include order (e.g. a
+  # shared Types.h), while still landing ahead of anything transitively re-reaching the
+  # real header afterward.
+  def splice_in_replacement(includes:, name:, replacement:)
+    return remove_matching_includes(includes: includes, modules: [name]) unless replacement
+
+    replaced = false
+    spliced = includes.map do |include|
+      if !replaced && include.filename.ext().downcase() == name.downcase()
+        replaced = true
+        UserInclude.new(replacement)
+      else
+        include
+      end
+    end
+    # This module's own header wasn't in the includes list at all -- no original
+    # position to preserve, so fall back to appending.
+    spliced << UserInclude.new(replacement) unless replaced
+
+    # A duplicate/case-variant entry beyond the first match (e.g. both 'module.h' and
+    # 'MODULE.H' present) has no meaningful position of its own to preserve -- drop it
+    # like remove_matching_includes always has.
+    spliced = remove_matching_includes(includes: spliced, modules: [name])
+    spliced
+  end
+
   # Remove includes that match the given module names (case-insensitive)
   # Returns a new array with matching includes removed
   def remove_matching_includes(includes:, modules:)

data/lib/ceedling/test_invoker/test_build_executor.rb

@@ -183,15 +183,27 @@ class TestBuildExecutor
 
       @partializer.sanitize( module_contents )
 
+      # The real header's guard is spoofed deliberately in every generated file, and the types
+      # header carries the dependencies its extracted types name.
+      module_include_guard = @partializer.extract_module_include_guard( config.header.filepath )
+      types_header_includes = @partializer.remap_types_header_includes(
+        name:     config.module,
+        includes: (config.source.includes + config.header.includes),
+        partials: testable.partials.configs,
+        test:     name
+      )
+
       # Generated once and shared by the implementation and interface headers below (via
       # their own includes lists), so a module tested and mocked in the same test file gets
       # exactly one C definition of each of its typedefs and aggregate types.
       types_header = @generator.generate_partial_types(
-        name:        config.module, # Module name, not test name -- two modules Partialed
-                                     # in the same test file must not collide on one
-                                     # shared types header filename
-        c_module:    module_contents,
-        output_path: testable.paths[:partials]
+        name:          config.module, # Module name, not test name -- two modules Partialed
+                                      # in the same test file must not collide on one
+                                      # shared types header filename
+        c_module:      module_contents,
+        output_path:   testable.paths[:partials],
+        includes:      types_header_includes,
+        include_guard: module_include_guard
       )
 
       implementation = @partializer.extract_implementation_functions(
@@ -235,7 +247,8 @@ class TestBuildExecutor
                                 test:     name
                               ),
         input_filepath:       config.source.filepath,
-        output_path:          testable.paths[:partials]
+        output_path:          testable.paths[:partials],
+        include_guard:        module_include_guard
       }
 
       unless implementation.nil?
@@ -256,7 +269,8 @@ class TestBuildExecutor
                                ),
         c_module:              module_contents,
         input_filepath:        config.header.filepath,
-        output_path:           testable.paths[:partials]
+        output_path:           testable.paths[:partials],
+        include_guard:         module_include_guard
       }
 
       unless interface.nil?

data/lib/version.rb

@@ -15,7 +15,7 @@
 module Ceedling
   module Version
     # Convenience constants for gem building, etc.
-    GEM = '1.1.8'
+    GEM = '1.1.10'
     TAG = GEM
 
     # If run as a script print Ceedling's version to $stdout

data/site-local/development/index.html

@@ -4080,6 +4080,13 @@ Please familiarize yourself with it before participating.</p>
 <p>Guidelines for contributing to this project — be it code, reviews,
 documentation, or issue reports.</p>
 </li>
+<li>
+<p><span class="twemoji"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M12 1 3 5v6c0 5.55 3.84 10.74 9 12 5.16-1.26 9-6.45 9-12V5zm0 6c1.4 0 2.8 1.1 2.8 2.5V11c.6 0 1.2.6 1.2 1.3v3.5c0 .6-.6 1.2-1.3 1.2H9.2c-.6 0-1.2-.6-1.2-1.3v-3.5c0-.6.6-1.2 1.2-1.2V9.5C9.2 8.1 10.6 7 12 7m0 1.2c-.8 0-1.5.5-1.5 1.3V11h3V9.5c0-.8-.7-1.3-1.5-1.3"/></svg></span> <strong><a href="https://github.com/ThrowTheSwitch/Ceedling?tab=security-ov-file">Security</a></strong></p>
+<hr />
+<p>See the <a href="https://github.com/ThrowTheSwitch/Ceedling/blob/master/docs/SECURITY.md">policy</a> for disclosure details and
+guidance on issues that vulnerability inspection tools may surface.
+Report a vulnerability through a <a href="https://github.com/ThrowTheSwitch/Ceedling/security/advisories/new">private advisory</a>.</p>
+</li>
 </ul>
 </div>
 <h2 id="projects">Projects</h2>

data/site-local/plugins/fff.html

@@ -4424,7 +4424,7 @@
 <h1 id="fake-function-framework-for-ceedling">Fake Function Framework for Ceedling</h1>
 <p>This plugin causes Ceedling to use the <a href="https://github.com/meekrosoft/fff">Fake Function Framework</a> for mocking instead of CMock, the default mocking framework packaged with Ceedling.</p>
 <p>Using <em>FFF</em> provides less strict mocking than CMock and affords more loosely-coupled tests.</p>
-<p>This Ceedling 1.x plugin incorporates a snapshot of <em>FFF</em> version 0.1.1 and supersedes a separately available <a href="https://github.com/ElectronVector/fake_function_framework">FFF Ceedling plugin project</a>. The built-in <em>FFF</em> plugin that now comes with Ceedling was derived from the ElectronVector project and is now maintained along with Ceedling and tracks its updates.</p>
+<p>This Ceedling 1.x plugin incorporates a snapshot of <em>FFF</em> version 1.1 and supersedes a separately available <a href="https://github.com/ElectronVector/fake_function_framework">FFF Ceedling plugin project</a>. The built-in <em>FFF</em> plugin that now comes with Ceedling was derived from the ElectronVector project and is now maintained along with Ceedling and tracks its updates.</p>
 <div class="admonition note">
 <p class="admonition-title">Special thanks to Matt Chernosky</p>
 <p><a href="http://www.electronvector.com">Matt Chernosky</a> originally developed this plugin