ceedling 1.0.1 → 1.1.0

data/spec/units/bin/projectinator_mixin_spec.rb

@@ -0,0 +1,362 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'projectinator'
+require 'ceedling/constants'
+require 'ceedling/ruby_expandinator'
+require 'ceedling/exceptions'
+
+describe Projectinator do
+  before(:each) do
+    @loginator = double('loginator')
+    allow(@loginator).to receive(:lazy)
+    allow(@loginator).to receive(:log)
+
+    @file_wrapper = double('file_wrapper')
+    allow(@file_wrapper).to receive(:exist?).and_return(false)
+    allow(@file_wrapper).to receive(:directory?).and_return(false)
+
+    @path_validator = double('path_validator')
+    allow(@path_validator).to receive(:standardize_paths)
+    allow(@path_validator).to receive(:filepath?).and_return(false)
+    allow(@path_validator).to receive(:validate).and_return(true)
+
+    @yaml_wrapper = double('yaml_wrapper')
+
+    @system_wrapper = double('system_wrapper')
+
+    # Default pass-through stub mirrors RubyExpandinator#expand's real behavior for
+    # strings without a `#{...}` pattern (the common case in these specs). Individual
+    # tests override with a tighter `.with(...)` expectation where expansion matters.
+    @ruby_expandinator = double('ruby_expandinator')
+    allow(@ruby_expandinator).to receive(:expand) { |s, source:| s }
+
+    @projectinator = described_class.new({
+      :file_wrapper   => @file_wrapper,
+      :path_validator => @path_validator,
+      :yaml_wrapper   => @yaml_wrapper,
+      :loginator      => @loginator,
+      :system_wrapper => @system_wrapper,
+      :ruby_expandinator => @ruby_expandinator
+    })
+  end
+
+  # =========================================================================
+  describe '#extract_mixins' do
+    it 'returns empty lists and leaves config unchanged when no :mixins key present' do
+      config = {:project => {:build_root => 'build'}}
+      enabled, load_paths = @projectinator.extract_mixins(config: config)
+
+      expect(enabled).to eq([])
+      expect(load_paths).to eq([])
+      expect(config).to have_key(:project)
+    end
+
+    it 'returns enabled list and empty load_paths when only :enabled is present' do
+      config = {
+        :mixins => {
+          :enabled => ['mixin_a', 'path/to/mixin_b.yml']
+        }
+      }
+
+      enabled, load_paths = @projectinator.extract_mixins(config: config)
+
+      expect(enabled).to eq(['mixin_a', 'path/to/mixin_b.yml'])
+      expect(load_paths).to eq([])
+    end
+
+    it 'returns empty enabled and load_paths list when only :load_paths is present' do
+      config = {
+        :mixins => {
+          :load_paths => ['support/mixins', 'vendor/mixins']
+        }
+      }
+
+      enabled, load_paths = @projectinator.extract_mixins(config: config)
+
+      expect(enabled).to eq([])
+      expect(load_paths).to eq(['support/mixins', 'vendor/mixins'])
+    end
+
+    it 'returns both enabled list and load_paths when both sections are present' do
+      config = {
+        :mixins => {
+          :enabled    => ['mixin_a'],
+          :load_paths => ['support/mixins']
+        }
+      }
+
+      enabled, load_paths = @projectinator.extract_mixins(config: config)
+
+      expect(enabled).to eq(['mixin_a'])
+      expect(load_paths).to eq(['support/mixins'])
+    end
+
+    it 'removes :mixins section from config after extraction' do
+      config = {
+        :project => {:build_root => 'build'},
+        :mixins  => {:enabled => ['mixin_a'], :load_paths => ['support']}
+      }
+
+      @projectinator.extract_mixins(config: config)
+
+      expect(config).not_to have_key(:mixins)
+      expect(config).to have_key(:project)
+    end
+
+    it 'expands inline Ruby expressions in :enabled entries' do
+      config = {
+        :mixins => {
+          :enabled    => ['#{ENV["MIXIN_NAME"]}'],
+          :load_paths => []
+        }
+      }
+      allow(@ruby_expandinator).to receive(:expand)
+        .with('#{ENV["MIXIN_NAME"]}', source: ':mixins ↳ :enabled')
+        .and_return('resolved_mixin_name')
+
+      enabled, _ = @projectinator.extract_mixins(config: config)
+
+      expect(enabled).to eq(['resolved_mixin_name'])
+    end
+
+    it 'expands inline Ruby expressions in :load_paths entries' do
+      config = {
+        :mixins => {
+          :enabled    => [],
+          :load_paths => ['#{File.join(Dir.pwd, "mixins")}']
+        }
+      }
+      allow(@ruby_expandinator).to receive(:expand)
+        .with('#{File.join(Dir.pwd, "mixins")}', source: ':mixins ↳ :load_paths')
+        .and_return('/project/mixins')
+
+      _, load_paths = @projectinator.extract_mixins(config: config)
+
+      expect(load_paths).to eq(['/project/mixins'])
+    end
+
+    it 'leaves entries without inline Ruby tokens unchanged' do
+      config = {
+        :mixins => {
+          :enabled    => ['plain_mixin'],
+          :load_paths => ['plain/path']
+        }
+      }
+
+      enabled, load_paths = @projectinator.extract_mixins(config: config)
+
+      expect(enabled).to eq(['plain_mixin'])
+      expect(load_paths).to eq(['plain/path'])
+    end
+
+    it 'raises CeedlingException when an entry contains inline Ruby and the feature is disabled' do
+      real_ruby_expandinator = RubyExpandinator.new # disabled by default
+      projectinator = described_class.new({
+        :file_wrapper   => @file_wrapper,
+        :path_validator => @path_validator,
+        :yaml_wrapper   => @yaml_wrapper,
+        :loginator      => @loginator,
+        :system_wrapper => @system_wrapper,
+        :ruby_expandinator => real_ruby_expandinator
+      })
+      config = { :mixins => { :enabled => ['#{ENV["MIXIN_NAME"]}'], :load_paths => [] } }
+
+      expect {
+        projectinator.extract_mixins(config: config)
+      }.to raise_error(CeedlingException, /:mixins/)
+    end
+  end
+
+  # =========================================================================
+  describe '#lookup_mixins' do
+    let(:builtins)       { {:builtin_mixin => {:foo => :bar}} }
+    let(:yaml_extension) { '.yml' }
+
+    it 'returns empty array for an empty mixin list' do
+      result = @projectinator.lookup_mixins(
+        mixins:         [],
+        load_paths:     ['support/mixins'],
+        builtins:       builtins,
+        yaml_extension: yaml_extension
+      )
+      expect(result).to eq([])
+    end
+
+    it 'returns an explicit filepath as-is without searching load_paths' do
+      allow(@path_validator).to receive(:filepath?).with('path/to/mixin.yml').and_return(true)
+
+      result = @projectinator.lookup_mixins(
+        mixins:         ['path/to/mixin.yml'],
+        load_paths:     ['support/mixins'],
+        builtins:       builtins,
+        yaml_extension: yaml_extension
+      )
+      expect(result).to eq(['path/to/mixin.yml'])
+    end
+
+    it 'resolves a simple name to a filepath in the first matching load_path' do
+      allow(@path_validator).to receive(:filepath?).with('my_mixin').and_return(false)
+      allow(@file_wrapper).to receive(:exist?).with('first/path/my_mixin.yml').and_return(true)
+
+      result = @projectinator.lookup_mixins(
+        mixins:         ['my_mixin'],
+        load_paths:     ['first/path', 'second/path'],
+        builtins:       builtins,
+        yaml_extension: yaml_extension
+      )
+      expect(result).to eq(['first/path/my_mixin.yml'])
+    end
+
+    it 'resolves a simple name to a filepath in the second load_path when not found in the first' do
+      allow(@path_validator).to receive(:filepath?).with('my_mixin').and_return(false)
+      allow(@file_wrapper).to receive(:exist?).with('first/path/my_mixin.yml').and_return(false)
+      allow(@file_wrapper).to receive(:exist?).with('second/path/my_mixin.yml').and_return(true)
+
+      result = @projectinator.lookup_mixins(
+        mixins:         ['my_mixin'],
+        load_paths:     ['first/path', 'second/path'],
+        builtins:       builtins,
+        yaml_extension: yaml_extension
+      )
+      expect(result).to eq(['second/path/my_mixin.yml'])
+    end
+
+    it 'returns the name unchanged when not found in any load_path (treated as builtin)' do
+      allow(@path_validator).to receive(:filepath?).with('builtin_mixin').and_return(false)
+      allow(@file_wrapper).to receive(:exist?).and_return(false)
+
+      result = @projectinator.lookup_mixins(
+        mixins:         ['builtin_mixin'],
+        load_paths:     ['support/mixins'],
+        builtins:       builtins,
+        yaml_extension: yaml_extension
+      )
+      expect(result).to eq(['builtin_mixin'])
+    end
+
+    it 'preserves input ordering across a mix of filepaths and simple names' do
+      allow(@path_validator).to receive(:filepath?).with('explicit.yml').and_return(true)
+      allow(@path_validator).to receive(:filepath?).with('named_mixin').and_return(false)
+      allow(@file_wrapper).to receive(:exist?).with('support/named_mixin.yml').and_return(true)
+
+      result = @projectinator.lookup_mixins(
+        mixins:         ['explicit.yml', 'named_mixin'],
+        load_paths:     ['support'],
+        builtins:       builtins,
+        yaml_extension: yaml_extension
+      )
+      expect(result).to eq(['explicit.yml', 'support/named_mixin.yml'])
+    end
+  end
+
+  # =========================================================================
+  describe '#validate_mixins' do
+    let(:builtins)       { {:builtin_mixin => {:foo => :bar}} }
+    let(:yaml_extension) { '.yml' }
+
+    it 'returns true for a mixin filepath that exists' do
+      allow(@path_validator).to receive(:filepath?).with('path/to/mixin.yml').and_return(true)
+      allow(@file_wrapper).to receive(:exist?).with('path/to/mixin.yml').and_return(true)
+
+      result = @projectinator.validate_mixins(
+        mixins:         ['path/to/mixin.yml'],
+        load_paths:     [],
+        builtins:       builtins,
+        source:         'Test',
+        yaml_extension: yaml_extension
+      )
+      expect(result).to be true
+    end
+
+    it 'returns false and logs an error for a mixin filepath that does not exist' do
+      allow(@path_validator).to receive(:filepath?).with('missing/mixin.yml').and_return(true)
+      allow(@file_wrapper).to receive(:exist?).with('missing/mixin.yml').and_return(false)
+
+      expect(@loginator).to receive(:log).with(
+        /cannot find mixin at missing\/mixin\.yml/i,
+        anything
+      )
+
+      result = @projectinator.validate_mixins(
+        mixins:         ['missing/mixin.yml'],
+        load_paths:     [],
+        builtins:       builtins,
+        source:         'Test',
+        yaml_extension: yaml_extension
+      )
+      expect(result).to be false
+    end
+
+    it 'returns true for a simple mixin name found in a load_path' do
+      allow(@path_validator).to receive(:filepath?).with('my_mixin').and_return(false)
+      allow(@file_wrapper).to receive(:exist?).with('support/my_mixin.yml').and_return(true)
+
+      result = @projectinator.validate_mixins(
+        mixins:         ['my_mixin'],
+        load_paths:     ['support'],
+        builtins:       builtins,
+        source:         'Test',
+        yaml_extension: yaml_extension
+      )
+      expect(result).to be true
+    end
+
+    it 'returns true for a simple mixin name matching a builtin key' do
+      allow(@path_validator).to receive(:filepath?).with('builtin_mixin').and_return(false)
+      allow(@file_wrapper).to receive(:exist?).and_return(false)
+
+      result = @projectinator.validate_mixins(
+        mixins:         ['builtin_mixin'],
+        load_paths:     [],
+        builtins:       builtins,
+        source:         'Test',
+        yaml_extension: yaml_extension
+      )
+      expect(result).to be true
+    end
+
+    it 'returns false and logs an error for a simple name not found anywhere' do
+      allow(@path_validator).to receive(:filepath?).with('unknown_mixin').and_return(false)
+      allow(@file_wrapper).to receive(:exist?).and_return(false)
+
+      expect(@loginator).to receive(:log).with(
+        /cannot be found/i,
+        anything
+      )
+
+      result = @projectinator.validate_mixins(
+        mixins:         ['unknown_mixin'],
+        load_paths:     ['support'],
+        builtins:       builtins,
+        source:         'Test',
+        yaml_extension: yaml_extension
+      )
+      expect(result).to be false
+    end
+
+    it 'returns false when any entry in a mixed list fails validation' do
+      allow(@path_validator).to receive(:filepath?).with('good/mixin.yml').and_return(true)
+      allow(@file_wrapper).to receive(:exist?).with('good/mixin.yml').and_return(true)
+
+      allow(@path_validator).to receive(:filepath?).with('bad/mixin.yml').and_return(true)
+      allow(@file_wrapper).to receive(:exist?).with('bad/mixin.yml').and_return(false)
+
+      allow(@loginator).to receive(:log)
+
+      result = @projectinator.validate_mixins(
+        mixins:         ['good/mixin.yml', 'bad/mixin.yml'],
+        load_paths:     [],
+        builtins:       builtins,
+        source:         'Test',
+        yaml_extension: yaml_extension
+      )
+      expect(result).to be false
+    end
+  end
+end

data/spec/units/bin/recursive_merger_spec.rb

@@ -0,0 +1,241 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'recursive_merger'
+
+describe RecursiveMerger do
+  # Helper: merge mixin into a fresh copy of config and return result
+  def merge(config, mixin)
+    RecursiveMerger.merge!(config, mixin)
+    config
+  end
+
+  # =========================================================================
+  describe '.merge! — non-overlapping keys' do
+    it 'adds mixin key to config when config does not have that key' do
+      config = {a: 1}
+      mixin  = {b: 2}
+      expect(merge(config, mixin)).to eq({a: 1, b: 2})
+    end
+
+    it 'adds mixin list key to config when config does not have that key' do
+      config = {}
+      mixin  = {paths: ['mixin/include']}
+      expect(merge(config, mixin)).to eq({paths: ['mixin/include']})
+    end
+
+    it 'adds mixin single-value key to config when config does not have that key' do
+      config = {}
+      mixin  = {name: 'value'}
+      expect(merge(config, mixin)).to eq({name: 'value'})
+    end
+  end
+
+  # =========================================================================
+  describe '.merge! — single value replaces single value' do
+    it 'replaces a string config value with the mixin string value' do
+      config = {build_root: 'old'}
+      mixin  = {build_root: 'new'}
+      expect(merge(config, mixin)).to eq({build_root: 'new'})
+    end
+
+    it 'replaces a symbol config value with the mixin symbol value' do
+      config = {flag: :off}
+      mixin  = {flag: :on}
+      expect(merge(config, mixin)).to eq({flag: :on})
+    end
+
+    it 'replaces a numeric config value with the mixin numeric value' do
+      config = {threads: 1}
+      mixin  = {threads: 4}
+      expect(merge(config, mixin)).to eq({threads: 4})
+    end
+  end
+
+  # =========================================================================
+  describe '.merge! — nested hash recursion' do
+    it 'merges non-overlapping keys inside a nested hash' do
+      config = {project: {build_root: 'build'}}
+      mixin  = {project: {threads: 4}}
+      expect(merge(config, mixin)).to eq({project: {build_root: 'build', threads: 4}})
+    end
+
+    it 'replaces a single value inside a nested hash when both sides have the same key' do
+      config = {project: {build_root: 'old', threads: 1}}
+      mixin  = {project: {build_root: 'new'}}
+      expect(merge(config, mixin)).to eq({project: {build_root: 'new', threads: 1}})
+    end
+
+    it 'recurses into multiply-nested hashes' do
+      config = {a: {b: {c: 'old'}}}
+      mixin  = {a: {b: {c: 'new', d: 'added'}}}
+      expect(merge(config, mixin)).to eq({a: {b: {c: 'new', d: 'added'}}})
+    end
+  end
+
+  # =========================================================================
+  describe '.merge! — list + list (general rule: mixin entries prepended)' do
+    it 'prepends single mixin list entry before config list entry' do
+      config = {paths: ['base']}
+      mixin  = {paths: ['override']}
+      expect(merge(config, mixin)).to eq({paths: ['override', 'base']})
+    end
+
+    it 'prepends multiple mixin list entries before config list entries' do
+      config = {paths: ['c']}
+      mixin  = {paths: ['a', 'b']}
+      expect(merge(config, mixin)).to eq({paths: ['a', 'b', 'c']})
+    end
+
+    it 'prepends mixin list into an empty config list' do
+      config = {paths: []}
+      mixin  = {paths: ['a', 'b']}
+      expect(merge(config, mixin)).to eq({paths: ['a', 'b']})
+    end
+
+    it 'produces only config entries when mixin list is empty' do
+      config = {paths: ['a', 'b']}
+      mixin  = {paths: []}
+      expect(merge(config, mixin)).to eq({paths: ['a', 'b']})
+    end
+
+    it 'prepends mixin list in a deep non-tools path' do
+      config = {defines: {test: {:'*' => ['SIMULATE', 'TEST']}}}
+      mixin  = {defines: {test: {:'*' => ['PROJECT_FEATURE_X']}}}
+      expect(merge(config, mixin)).to eq(
+        {defines: {test: {:'*' => ['PROJECT_FEATURE_X', 'SIMULATE', 'TEST']}}}
+      )
+    end
+
+    it 'prepends mixin list for a sibling key of :arguments under :tools' do
+      # :flags is NOT :arguments so the general (prepend) rule applies
+      config = {tools: {test_compiler: {flags: ['-Wall']}}}
+      mixin  = {tools: {test_compiler: {flags: ['-Werror']}}}
+      expect(merge(config, mixin)).to eq(
+        {tools: {test_compiler: {flags: ['-Werror', '-Wall']}}}
+      )
+    end
+  end
+
+  # =========================================================================
+  describe '.merge! — list + list (:tools :name :arguments exception: entries appended)' do
+    it 'appends mixin :arguments after config :arguments for a single tool' do
+      config = {tools: {test_compiler: {arguments: ['-O2']}}}
+      mixin  = {tools: {test_compiler: {arguments: ['-O0']}}}
+      # -O0 must come AFTER -O2 so the compiler honours -O0
+      expect(merge(config, mixin)).to eq(
+        {tools: {test_compiler: {arguments: ['-O2', '-O0']}}}
+      )
+    end
+
+    it 'appends multiple mixin :arguments after config :arguments' do
+      config = {tools: {test_linker: {arguments: ['-lm']}}}
+      mixin  = {tools: {test_linker: {arguments: ['-lpthread', '-ldl']}}}
+      expect(merge(config, mixin)).to eq(
+        {tools: {test_linker: {arguments: ['-lm', '-lpthread', '-ldl']}}}
+      )
+    end
+
+    it 'appends mixin :arguments when config :arguments is empty' do
+      config = {tools: {test_compiler: {arguments: []}}}
+      mixin  = {tools: {test_compiler: {arguments: ['-O0']}}}
+      expect(merge(config, mixin)).to eq(
+        {tools: {test_compiler: {arguments: ['-O0']}}}
+      )
+    end
+
+    it 'does NOT treat a key at [:tools, :name, :other] as the exception' do
+      # Only :arguments at path depth 3 triggers the exception
+      config = {tools: {test_compiler: {other: ['a']}}}
+      mixin  = {tools: {test_compiler: {other: ['b']}}}
+      expect(merge(config, mixin)).to eq(
+        {tools: {test_compiler: {other: ['b', 'a']}}}
+      )
+    end
+  end
+
+  # =========================================================================
+  describe '.merge! — single mixin value merged into config list' do
+    it 'prepends mixin single string value into config list' do
+      config = {foo: ['bar', 'baz']}
+      mixin  = {foo: 'high'}
+      expect(merge(config, mixin)).to eq({foo: ['high', 'bar', 'baz']})
+    end
+
+    it 'prepends mixin symbol value into config list' do
+      config = {foo: [:a, :b]}
+      mixin  = {foo: :high}
+      expect(merge(config, mixin)).to eq({foo: [:high, :a, :b]})
+    end
+
+    it 'prepends mixin hash value into config list' do
+      config = {items: ['a', :b]}
+      mixin  = {items: {key: 'val'}}
+      expect(merge(config, mixin)).to eq({items: [{key: 'val'}, 'a', :b]})
+    end
+
+    it 'prepends mixin single value into an empty config list' do
+      config = {foo: []}
+      mixin  = {foo: 'only'}
+      expect(merge(config, mixin)).to eq({foo: ['only']})
+    end
+  end
+
+  # =========================================================================
+  describe '.merge! — config single value replaced by mixin list' do
+    it 'replaces config single value with mixin list' do
+      config = {foo: 'scalar'}
+      mixin  = {foo: ['a', 'b']}
+      # Type mismatch flagged by validate_merge(); mixin wins per RecursiveMerger
+      expect(merge(config, mixin)).to eq({foo: ['a', 'b']})
+    end
+  end
+
+  # =========================================================================
+  describe '.merge! — mixin hash replaces config non-hash (non-list)' do
+    it 'replaces a config string value with a mixin hash' do
+      config = {a: 'scalar'}
+      mixin  = {a: {b: 1}}
+      expect(merge(config, mixin)).to eq({a: {b: 1}})
+    end
+  end
+
+  # =========================================================================
+  describe '.merge! — realistic project configuration scenarios' do
+    it 'merges a project config with a mixin adding new keys and prepending include paths' do
+      config = {
+        project: {build_root: 'build', test_file_prefix: 'test_'},
+        paths:   {include: ['src/include']}
+      }
+      mixin = {
+        project: {test_threads: 4},
+        paths:   {include: ['vendor/include']}
+      }
+      result = merge(config, mixin)
+      expect(result[:project]).to eq({build_root: 'build', test_file_prefix: 'test_', test_threads: 4})
+      # Mixin include path appears first — searched before project include path
+      expect(result[:paths][:include]).to eq(['vendor/include', 'src/include'])
+    end
+
+    it 'correctly orders two sequential merges simulating config then cmdline mixin' do
+      # Simulate: base → config_mixin → cmdline_mixin (cmdline has highest priority)
+      config = {project: {build_root: 'base'}, paths: {include: ['base/include']}}
+
+      config_mixin  = {project: {build_root: 'config_root'}, paths: {include: ['config/include']}}
+      cmdline_mixin = {project: {build_root: 'cmdline_root'}, paths: {include: ['cmdline/include']}}
+
+      RecursiveMerger.merge!(config, config_mixin)
+      RecursiveMerger.merge!(config, cmdline_mixin)
+
+      # cmdline_mixin is merged last, so its single value wins
+      expect(config[:project][:build_root]).to eq('cmdline_root')
+      # cmdline paths are prepended last, so they appear first in the combined list
+      expect(config[:paths][:include]).to eq(['cmdline/include', 'config/include', 'base/include'])
+    end
+  end
+end