ceedling 1.1.10 → 1.2.0

data/plugins/dependencies/lib/dependency_commands.rb

@@ -0,0 +1,72 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# The commands that fetch and build one dependency, in the order they run.
+#
+# Fetching uses the plugin's configurable tools (:deps_zip, :deps_git_clone, and the
+# rest), filling in each tool's arguments from the dependency's fetch settings. Custom
+# fetch commands and build commands are command lines the user wrote. Each becomes a tool
+# whose executable is its first word and whose arguments are the rest exactly as written,
+# so quoting and spacing reach the shell unchanged. A built-in build step such as
+# :build_lib stays a symbol for the plugin to carry out.
+#
+# `builder` makes a runnable command from a tool and its arguments, as
+# ToolExecutor#build_command_line does.
+class DependencyCommands
+
+  def initialize(tools:, builder:)
+    @tools   = tools
+    @builder = builder
+  end
+
+  def fetch(spec)
+    fetch = spec.fetch
+
+    case spec.fetch_method
+    when :zip      then [command( :zip, fetch[:source] )]
+    when :tar_gzip then [command( :tar_gzip, fetch[:source] )]
+    when :git      then git( fetch )
+    when :svn      then [command( :subversion, option( '--revision', fetch[:revision] ), fetch[:source] )]
+    when :custom   then custom( fetch[:executable] )
+    else []
+    end
+  end
+
+  def build(spec)
+    return spec.build_steps.map { |step| step.is_a?( Symbol ) ? step : written( step ) }
+  end
+
+  private
+
+  def command(tool, *args)
+    return @builder.call( @tools.fetch( tool ), *args )
+  end
+
+  # A shallow clone, or a full clone and checkout when a commit hash is wanted
+  def git(fetch)
+    branch = option( '-b', fetch[:tag] || fetch[:branch] )
+    return [command( :git_clone, branch, '--depth 1', fetch[:source] )] if fetch[:hash].nil?
+
+    return [command( :git_clone, branch, '', fetch[:source] ), command( :git_checkout, fetch[:hash] )]
+  end
+
+  # Custom commands, one or a list, each named for its place in the list
+  def custom(lines)
+    return Array( lines ).map.with_index( 1 ) { |line, index| written( line, "Dependencies custom command ##{index}" ) }
+  end
+
+  def option(flag, value)
+    return value.to_s.empty? ? '' : "#{flag} #{value}"
+  end
+
+  # A command line as written: its first word runs, and the rest passes through untouched
+  def written(line, name = nil)
+    executable, arguments = line.strip.split( /\s+/, 2 )
+    return @builder.call( { name: name || executable, executable: executable, arguments: Array( arguments ) } )
+  end
+
+end

data/plugins/dependencies/lib/dependency_environment.rb

@@ -0,0 +1,57 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/exceptions'
+
+# A dependency's :environment entries, in effect only while its own commands run.
+#
+# Each entry sets a variable (`NAME=value`), appends to it (`NAME+=value`), or removes
+# text from it (`NAME-=value`), in order. Appended and removed text is used exactly as
+# written, leading spaces included. Afterward every variable returns to its earlier
+# value, and one that was unset is removed again, so one dependency's environment never
+# reaches the next dependency or Ceedling itself.
+class DependencyEnvironment
+
+  # Text after += or -= is kept exactly, so it can carry its own delimiter (a space
+  # between compiler flags). A value after = loses its leading spaces.
+  ENTRY = /\A(\w+)\s*(?:(\+=|-=)(.*)|(=)\s*(.*))\z/
+
+  def initialize(entries, dependency:)
+    @assignments = entries.map do |entry|
+      match = ENTRY.match( entry.to_s ) or
+        raise CeedlingException.new( "Environment entry `#{entry}` for dependency `#{dependency}` is not NAME=value, NAME+=value, or NAME-=value." )
+      name, operator, text, equals, value = match.captures
+      [name, operator || equals, operator ? text : value]
+    end
+  end
+
+  # Runs the block with the entries applied to `env`, then restores `env`
+  def apply(env = ENV)
+    saved = @assignments.map( &:first ).uniq.to_h { |name| [name, env[name]] }
+    @assignments.each { |name, operator, value| env[name] = assigned( env[name].to_s, operator, value ) }
+
+    return yield
+  ensure
+    restore( env, saved )
+  end
+
+  private
+
+  # Each variable back to its earlier value, or removed when it had none
+  def restore(env, saved)
+    saved&.each { |name, value| value.nil? ? env.delete( name ) : env[name] = value }
+  end
+
+  def assigned(current, operator, value)
+    case operator
+    when '+=' then current + value
+    when '-=' then current.gsub( value, '' )
+    else value
+    end
+  end
+
+end

data/plugins/dependencies/lib/dependency_spec.rb

@@ -0,0 +1,145 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/exceptions'
+
+# One configured dependency, validated and normalized.
+#
+# Each dependency names its paths under :paths, and each path falls back to another when
+# left out: :source and :fetch to each other, :build to :source then :fetch, :artifact to
+# :build. With none configured, every path is `dependencies/<task name>`. Artifacts
+# (libraries, executables, includes, sources) live under the artifact path. An optional
+# :deploy path receives deployed copies.
+#
+# The task name is the configured name's word characters, which `dependencies:*` tasks
+# use, so it must be non-empty and unique among dependencies.
+class DependencySpec
+
+  FETCH_METHODS = %i[none zip tar_gzip git svn custom].freeze
+
+  # Fetch methods that read from a configured :source
+  SOURCED = %i[zip tar_gzip git svn].freeze
+
+  # Include entries that are globs or add/subtract notation rather than plain paths
+  INCLUDE_GLOB = /(?:\A[+-]:)|(?:\*\*)/
+
+  attr_reader :name, :task_name, :fetch
+
+  def self.build_all(deps)
+    specs = deps.map { |dep| new( dep ) }
+
+    specs.group_by( &:task_name ).each do |task_name, same|
+      next if same.size == 1
+
+      names = same.map { |spec| "`#{spec.name}`" }.join( ' and ' )
+      raise CeedlingException.new( "Dependencies #{names} share the task name #{task_name}. Give them distinct names." )
+    end
+
+    return specs
+  end
+
+  def initialize(dep)
+    @dep       = dep
+    @name      = dep[:name] or raise CeedlingException.new( 'Each dependency must have a :name.' )
+    @task_name = task_name_for( @name )
+    @fetch     = dep[:fetch] || {}
+    @paths     = dep[:paths] || {}
+    @artifacts = dep[:artifacts] || {}
+
+    problem = fetch_problem
+    raise CeedlingException.new( problem ) unless problem.nil?
+
+    freeze
+  end
+
+  # Settings given as lists, each empty when left out
+  def build_steps = Array( @dep[:build] )
+  def environment = Array( @dep[:environment] )
+  def defines     = Array( @dep[:defines] )
+  def flags       = Array( @dep[:flags] )
+  def libraries   = Array( @dep[:libraries] )
+  def libpaths    = Array( @dep[:libpaths] )
+
+  def fetch_method
+    return @fetch[:method]
+  end
+
+  def fetch_path    = @paths[:fetch] || @paths[:source] || default_path
+  def source_path   = @paths[:source] || @paths[:fetch] || default_path
+  def build_path    = @paths[:build] || @paths[:source] || @paths[:fetch] || default_path
+  def artifact_path = @paths[:artifact] || @paths[:build] || default_path
+
+  # Every configured path, for cleaning a fetched dependency away, or only the artifact
+  # path, for cleaning one that is not fetched. The artifact path never includes the
+  # source path, which a dependency that is not fetched keeps.
+  def working_paths(artifacts_only: false)
+    return [artifact_path] - [source_path, fetch_path] if artifacts_only
+
+    paths = @paths.except( :deploy ).values.compact.uniq
+    return paths.empty? ? [default_path] : paths
+  end
+
+  # Where deploying copies dynamic libraries and executables, never cleaned away
+  def deploy_path(default)
+    return @paths[:deploy] || default
+  end
+
+  # Search paths a dependency's undocumented :source and :include keys add to `:build_lib`
+  def build_lib_search_paths
+    return (Array( @dep[:source] ) + Array( @dep[:include] )).compact.uniq
+  end
+
+  # Static libraries as configured, relative to the artifact path
+  def static_library_entries = Array( @artifacts[:static_libraries] )
+
+  def static_libraries  = artifacts( :static_libraries )
+  def dynamic_libraries = artifacts( :dynamic_libraries )
+  def executables       = artifacts( :executables )
+  def include_files     = artifacts( :includes )
+  def source_paths      = artifacts( :source )
+
+  # Directories to search for this dependency's headers. A header names its directory, a
+  # glob expands through `collector` against the disk, and anything else is a directory.
+  def include_directories(collector)
+    return Array( @artifacts[:includes] ).flat_map do |include|
+      path = File.join( artifact_path, include )
+      if include.end_with?( '.h' ) then [File.dirname( path )]
+      elsif include.match?( INCLUDE_GLOB ) then collector.call( path )
+      else [path]
+      end
+    end.uniq
+  end
+
+  private
+
+  def task_name_for(name)
+    task_name = name.to_s.gsub( /\W/, '' )
+    return task_name unless task_name.empty?
+
+    raise CeedlingException.new( "Dependency name `#{name}` needs letters or digits for its task name." )
+  end
+
+  def default_path
+    return File.join( 'dependencies', @task_name )
+  end
+
+  def artifacts(kind)
+    return Array( @artifacts[kind] ).map { |path| File.join( artifact_path, path ) }
+  end
+
+  # What is wrong with the fetch configuration, or nil
+  def fetch_problem
+    method = fetch_method
+    return nil if method.nil?
+    return "Unknown fetch method `#{method}` for dependency `#{@name}`." unless FETCH_METHODS.include?( method )
+    return "Fetch method :#{method} for dependency `#{@name}` needs a :source." if SOURCED.include?( method ) and @fetch[:source].to_s.empty?
+    return "Fetch method :custom for dependency `#{@name}` needs :executable commands." if method == :custom and Array( @fetch[:executable] ).empty?
+
+    return nil
+  end
+
+end

data/plugins/fff/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/plugins/fff/Rakefile

@@ -7,6 +7,14 @@
 
 require 'rake'
 require 'rspec/core/rake_task'
+require 'rbconfig'
+
+def windows?()
+  return (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+end
+
+# Add `ruby` to the command line on Windows to execute the Ruby-based shell script bin/ceedling
+CEEDLING_CLI_EXEC = "#{'ruby ' if windows?}../../../../bin/ceedling"
 
 desc "Run all rspecs"
 RSpec::Core::RakeTask.new(:spec) do |t|
@@ -18,8 +26,12 @@ end
 desc "Run integration test on example"
 task :integration_test do
     chdir("./examples/fff_example") do
-        sh "ceedling clobber"
-        sh "ceedling test:all"
+        # Repo-relative path (rather than a bare `ceedling` resolved via PATH, i.e.
+        # the separately gem-installed copy) so this exercises the exact same
+        # bin/lib source this repo's other tests instrument, matching the
+        # dependencies/module_generator plugins' own Rakefiles.
+        sh "#{CEEDLING_CLI_EXEC} clobber"
+        sh "#{CEEDLING_CLI_EXEC} test:all"
     end
 end
 

data/plugins/fff/examples/fff_example/project.yml

@@ -138,7 +138,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/fff/lib/fff.rb

@@ -3,6 +3,11 @@
 #   ThrowTheSwitch.org
 #   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
+#
+#   Derived from the Fake Function Framework Ceedling plugin, absorbed as a
+#   modified snapshot in 2024 after seven years as a submodule.
+#   Copyright (c) 2018 ElectronVector -- MIT
+#   ⏩️ https://github.com/ElectronVector/fake_function_framework
 # =========================================================================
 
 require 'ceedling/plugins/plugin'
@@ -37,15 +42,17 @@ class FffCMockWrapper
     @silent        = (@cm_config.verbosity < 2)
 
     # These are the additional files to include in the mock files.
-    @includes_h_pre_orig_header  = (@cm_config.includes || @cm_config.includes_h_pre_orig_header || []).map{|h| h =~ /</ ? h : "\"#{h}\""}
-    @includes_h_post_orig_header = (@cm_config.includes_h_post_orig_header || []).map{|h| h =~ /</ ? h : "\"#{h}\""}
-    @includes_c_pre_header       = (@cm_config.includes_c_pre_header || []).map{|h| h =~ /</ ? h : "\"#{h}\""}
-    @includes_c_post_header      = (@cm_config.includes_c_post_header || []).map{|h| h =~ /</ ? h : "\"#{h}\""}
+    @includes_h_pre_orig_header  = (@cm_config.includes || @cm_config.includes_h_pre_orig_header || []).map{|h| h.match?(/</) ? h : "\"#{h}\""}
+    @includes_h_post_orig_header = (@cm_config.includes_h_post_orig_header || []).map{|h| h.match?(/</) ? h : "\"#{h}\""}
+    @includes_c_pre_header       = (@cm_config.includes_c_pre_header || []).map{|h| h.match?(/</) ? h : "\"#{h}\""}
+    @includes_c_post_header      = (@cm_config.includes_c_post_header || []).map{|h| h.match?(/</) ? h : "\"#{h}\""}
   end
 
-  def setup_mocks(files)
+  # Matches CMock's own entry point, which Ceedling calls with the folder a mock's
+  # #include names. A fake is written below the mock root at that folder, as CMock would.
+  def setup_mocks(files, folder = nil)
     [files].flatten.each do |src|
-      generate_mock (src)
+      generate_mock(src, folder)
     end
   end
 
@@ -53,12 +60,13 @@ class FffCMockWrapper
       module_name = File.basename(header_file_to_mock, '.h')
       puts( "Creating fake functions for #{module_name}..." ) unless @silent
       mock_name = @cm_config.mock_prefix + module_name + @cm_config.mock_suffix
-      mock_path = @cm_config.mock_path + (folder.nil? ? '' : File.join(folder,''))
+      mock_path = folder.nil? ? @cm_config.mock_path : File.join(@cm_config.mock_path, folder)
       if @cm_config.subdir
           # If a subdirectory has been configured, append it to the mock path.
           mock_path = "#{mock_path}/#{@cm_config.subdir}"
       end
       full_path_for_mock = "#{mock_path}/#{mock_name}"
+      c_name = c_name_for(mock_name, folder)
 
       # Parse the header file so we know what to mock.
       parsed_header = @cm_parser.parse(module_name, File.read(header_file_to_mock))
@@ -72,16 +80,29 @@ class FffCMockWrapper
       # Create the mock header.
       File.open("#{full_path_for_mock}.h", 'w') do |f|
         f.write(FffMockGenerator.create_mock_header(module_name, mock_name, parsed_header,
-          @includes_h_pre_orig_header, @includes_h_post_orig_header))
+          @includes_h_pre_orig_header, @includes_h_post_orig_header, c_name: c_name))
       end
 
       # Create the mock source file.
       File.open("#{full_path_for_mock}.c", 'w') do |f|
         f.write(FffMockGenerator.create_mock_source(mock_name, parsed_header,
-          @includes_c_pre_orig_header, @includes_c_post_orig_header))
+          @includes_c_pre_orig_header, @includes_c_post_orig_header, c_name: c_name))
       end
   end
 
+  # The name for a fake's guard and control functions, as CMock forms it. With
+  # :mock_name_include_folder, the folder below the mock root comes first, so two
+  # same-named fakes stay distinct and match the runner's calls. A leading ./ is
+  # dropped, and characters a C identifier can't hold become `_`, as Unity's
+  # TypeSanitizer does.
+  def c_name_for(mock_name, folder)
+    mock_folder = [@cm_config.subdir, folder].compact
+    return mock_name unless @cm_config.mock_name_include_folder && !mock_folder.empty?
+
+    identity = File.join( *mock_folder, '' ).sub( %r{\A(?:\.[/\\])+}, '' ) + mock_name
+    return identity.gsub( %r{[-/\\.,\s]}, '_' )
+  end
+
 end
 
 # Switch out the CMock with FFF Mock Generator