ceedling 1.0.1 → 1.1.0

data/bin/cli_helper.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
 # =========================================================================
 
@@ -10,18 +10,59 @@ require 'app_cfg'
 # From Ceedling application
 require 'ceedling/constants'
 require 'ceedling/exceptions'
+require 'ceedling/rake_app/rakefile_component_resolver'
+require 'versionator' # Outisde DIY context
 
 class CliHelper
 
-  constructor :file_wrapper, :actions_wrapper, :config_walkinator, :path_validator, :loginator, :system_wrapper
+  constructor :file_wrapper, :actions_wrapper, :config_walkinator, :path_validator, :rake_task_registry, :loginator, :reportinator, :system_wrapper, :ruby_expandinator
 
   def setup
     # Aliases
     @actions = @actions_wrapper
+    @registry = @rake_task_registry
+  end
+
+  # For simple CLI commands needing immediate logging with no verbosity management
+  def console_project_name(config)
+    banner = project_name_banner( config )
+    @loginator.console( banner ) if banner
+  end
+
+  
+  # For CLI commands needing logging with verbosity management
+  def log_project_name(config)
+    banner = project_name_banner( config )
+    @loginator.log( "\n" + banner ) if banner
+  end
+
+  def manufacture_app_version(app_cfg)
+    return Versionator.new(
+      app_cfg[:ceedling_root_path],
+      app_cfg[:ceedling_vendor_path]
+    )
   end
 
 
-  def project_exists?( path, op, *components )
+  def help_footer(ceedling_tag='master')
+    @loginator.console() # Blank line for spacing
+
+    # Documentation incorporating Ceedling version tag in URL
+    msg = "Ceedling Packet User Manual (v#{ceedling_tag})\n" +
+          "https://throwtheswitch.github.io/Ceedling/#{ceedling_tag}/\n\n"
+    @loginator.console( msg, LogLabels::DOCUMENTATION )
+
+    # Ceedling Suite
+    msg = "Ceedling Suite can help you do more ➡️ https://www.thingamabyte.com/ceedling\n\n"
+    @loginator.console( msg, LogLabels::COMMERCIAL )
+
+    # GitHub Sponsors
+    msg = "Please consider supporting this work ➡️ https://github.com/sponsors/throwtheswitch\n\n"
+    @loginator.console( msg, LogLabels::REQUEST )
+  end
+
+
+  def project_exists?(path, op, *components)
     exists = []
 
     components.each do |f|
@@ -74,7 +115,7 @@ class CliHelper
 
     # Environment variable
     if !env['WHICH_CEEDLING'].nil?
-      @loginator.log( " > Set which Ceedling using environment variable WHICH_CEEDLING", Verbosity::OBNOXIOUS )
+      @loginator.console( " > Set which Ceedling using environment variable WHICH_CEEDLING" ) 
       which_ceedling = env['WHICH_CEEDLING'].strip()
       which_ceedling = :gem if (which_ceedling.casecmp( 'gem' ) == 0)
     end
@@ -84,7 +125,7 @@ class CliHelper
       value, _ = @config_walkinator.fetch_value( :project, :which_ceedling, hash:config )
       if !value.nil?
         which_ceedling = value.strip()
-        @loginator.log( " > Set which Ceedling from config :project ↳ :which_ceedling => #{which_ceedling}", Verbosity::OBNOXIOUS )
+        @loginator.lazy( Verbosity::OBNOXIOUS ) { " > Set which Ceedling from config :project ↳ :which_ceedling => #{which_ceedling}" }
         which_ceedling = :gem if (which_ceedling.casecmp( 'gem' ) == 0)
       end
     end
@@ -133,6 +174,18 @@ class CliHelper
   end
 
 
+  def build_rake_task_registry(config:)
+    paths = RakefileComponentResolver.resolve(
+      config,
+      CEEDLING_APPCFG[:ceedling_lib_path],
+      CEEDLING_APPCFG[:ceedling_plugins_path]
+    )
+
+    @registry.register_test_tasks( paths )
+    @registry.register_release_tasks( paths )
+  end
+
+
   def load_ceedling(config:, rakefile_path:, default_tasks:[])
     # Set default tasks
     Rake::Task.define_task(:default => default_tasks) if !default_tasks.empty?
@@ -149,31 +202,46 @@ class CliHelper
     # Do nothing if no test case filters
     return if (include.nil? || include.empty?) && (exclude.nil? || exclude.empty?)
 
-    # TODO: When we can programmatically check if a task is a test task,
-    #       raise an exception if --graceful-fail is set without test operations
+    unless test_task?( tasks: (tasks.empty? ? default_tasks : tasks ) )
+      raise CeedlingException.new( "Test case filters are only applicable to test tasks. No test tasks were specified." )
+    end
+
+    already_enabled = false
 
     # Add test runner configuration setting necessary to use test case filters
     value, _ = @config_walkinator.fetch_value( :test_runner, hash:config )
     if value.nil?
       # If no :test_runner section, create the whole thing
       config[:test_runner] = {:cmdline_args => true}
+      already_enabled = false
     else
-      # If a :test_runner section, just set :cmdlne_args
+      # If a :test_runner section, just set :cmdline_args
+      already_enabled = (value[:cmdline_args] == true)
       value[:cmdline_args] = true
     end
+
+    # Only log if we actually changed something.
+    # No need to notify the user that we enabled a setting that was already enabled.
+    unless already_enabled
+      @loginator.log( "Enabled :test_runner ↳ :cmdline_args because test case filters are in use.", Verbosity::COMPLAIN, LogLabels::NOTICE )
+    end
   end
 
 
   def process_graceful_fail(config:, cmdline_graceful_fail:, tasks:, default_tasks:)
-    # TODO: When we can programmatically check if a task is a test task,
-    #       raise an exception if --graceful-fail is set without test operations
-
     # Precedence
     #  1. Command line option
     #  2. Configuration entry
 
     # If command line option was set, use it
-    return cmdline_graceful_fail if !cmdline_graceful_fail.nil?
+    if !cmdline_graceful_fail.nil?
+
+      if cmdline_graceful_fail && !test_task?( tasks: (tasks.empty? ? default_tasks : tasks ) )
+        raise CeedlingException.new( "The graceful fail option is only applicable to test tasks. No test tasks were specified." )
+      end
+
+      return cmdline_graceful_fail
+    end
 
     # If configuration contains :graceful_fail, use it
     value, _ = @config_walkinator.fetch_value( :test_build, :graceful_fail, hash:config )
@@ -183,6 +251,11 @@ class CliHelper
   end
 
 
+  def process_mixin_filepaths(mixins)
+    mixins.reject {|m| m.start_with?(MIXIN_SIGIL_INLINE_YAML)}
+  end
+
+
   def process_logging_path(config)
     build_root, _ = @config_walkinator.fetch_value( :project, :build_root, hash:config )
 
@@ -224,31 +297,43 @@ class CliHelper
   end
 
 
-  # TODO: This is a hack until Rake is fully removed and plugin/build tasks incorporate a purpose classification
-  def build_or_plugin_task?(tasks:, default_tasks:)
-    _tasks = tasks.empty?() ? default_tasks.dup() : tasks.dup()
+  # Enables inline Ruby string expansion (security-sensitive) if requested at the command
+  # line. One-directional: never disables an already-enabled feature.
+  def set_ruby_replacement(enabled)
+    @ruby_expandinator.enable! if enabled
+  end
 
-    # These namespace-less tasks are definitely build tasks
-    return true if _tasks.include?('test')
-    return true if _tasks.include?('release')
 
-    # Namespace-less (clobber, clean, etc.), files:, and paths: tasks are not build / plugin tasks
-    #  1. Filter out tasks lacking a namespace
-    #  2. Look for any tasks other than paths: or files:
-    _tasks.select! {|t| t.include?( ':') }
-    _tasks.reject! {|t| t =~ /(^files:|^paths:)/}
+  def test_task?(tasks:)
+    return tasks.any? { |task| @registry.task_is?( task, RakeTaskRegistry::TAG_TEST ) }
+  end
+
 
-    return !_tasks.empty?
+  def build_task?(tasks:)
+    return tasks.any? { |task| @registry.task_is?( task, RakeTaskRegistry::TAG_BUILD ) }
   end
 
 
   def print_rake_tasks()
-    # (This required digging into Rake internals a bit.)
+    # This all required digging into Rake internals a bit.
+
+    # Monkey patch Rake::Application class to prevent writing to $stdout directly
+    require 'rake_patches'
+    Rake::Application.include( CaptureHelpOutput )
+
     Rake.application.define_singleton_method(:name=) {|n| @name = n}
     Rake.application.name = 'ceedling'
     Rake.application.options.show_tasks = :tasks
     Rake.application.options.show_task_pattern = /^(?!.*build).*$/
-    Rake.application.display_tasks_and_comments()
+
+    # Use our monkey patched help string accessor instead of Rake's `display_tasks_and_comments()`
+    rake_tasks = Rake.application.capture_display_tasks()
+    # Indent task help to match Thow
+    indentation = ' ' * 2
+    rake_tasks.gsub!(/^/, indentation)
+
+    # Print Rake task list directly to the console
+    @loginator.console( rake_tasks )
   end
 
 
@@ -277,27 +362,48 @@ class CliHelper
   end
 
 
-  # Set global consts for verbosity and debug
-  def set_verbosity(verbosity=nil)
-    # If we have already set verbosity, there's nothing to do here
-    return PROJECT_VERBOSITY if @system_wrapper.constants_include?('PROJECT_VERBOSITY')
+  # Sets global PROJECT_VERBOSITY and PROJECT_DEBUG constants used throughout
+  # the Ceedling application. Once set, subsequent calls are no-ops — the method
+  # returns the already-established verbosity — unless `override:` is true.
+  #
+  # `verbosity` accepts:
+  #   - nil            → defaults to Verbosity::NORMAL
+  #   - Integer        → used directly as a Verbosity level (e.g. Verbosity::OBNOXIOUS)
+  #   - numeric string → parsed as an integer verbosity level (e.g. '4')
+  #   - named string   → looked up in VERBOSITY_OPTIONS hash (e.g. 'debug', 'normal')
+  def set_verbosity(verbosity=nil, override: true)
+    # Idempotency guard: if verbosity is already established, return it as-is.
+    # `override: true` bypasses this to allow forced re-configuration (check command).
+    return PROJECT_VERBOSITY if !override && @system_wrapper.constants_include?('PROJECT_VERBOSITY')
+
+    verbosity = 
+      if verbosity.nil?
+        Verbosity::NORMAL
+
+      # Integer Verbosity constants (e.g. Verbosity::OBNOXIOUS) pass through directly
+      elsif verbosity.is_a?( Integer )
+        verbosity
+
+      # Numeric string (e.g. '4') — convert to integer
+      elsif verbosity.to_i.to_s == verbosity
+        verbosity.to_i
+
+      # Named string (e.g. 'debug', 'normal') — look up integer value
+      elsif VERBOSITY_OPTIONS.include? verbosity.to_sym
+        VERBOSITY_OPTIONS[verbosity.to_sym]
 
-    verbosity = if verbosity.nil?
-                  Verbosity::NORMAL
-                elsif verbosity.to_i.to_s == verbosity
-                  verbosity.to_i
-                elsif VERBOSITY_OPTIONS.include? verbosity.to_sym
-                  VERBOSITY_OPTIONS[verbosity.to_sym]
-                else
-                  raise "Unkown Verbosity '#{verbosity}' specified"
-                end
+      else
+        raise "Unkown Verbosity '#{verbosity}' specified"
+      end
 
     # Create global constant PROJECT_VERBOSITY
+    Object.send(:remove_const, 'PROJECT_VERBOSITY') if Object.const_defined?('PROJECT_VERBOSITY')
     Object.module_eval("PROJECT_VERBOSITY = verbosity")
     PROJECT_VERBOSITY.freeze()
 
     # Create global constant PROJECT_DEBUG
     debug = (verbosity == Verbosity::DEBUG)
+    Object.send(:remove_const, 'PROJECT_DEBUG') if Object.const_defined?('PROJECT_DEBUG')
     Object.module_eval("PROJECT_DEBUG = debug")
     PROJECT_DEBUG.freeze()
 
@@ -354,7 +460,7 @@ class CliHelper
 
 
   def copy_docs(ceedling_root, dest)
-    docs_path = File.join( dest, 'docs' )
+    docs_path_ceedling = File.join( dest, 'ceedling' )
 
     # Hash that will hold documentation copy paths
     #  - Key: (modified) destination documentation path
@@ -363,7 +469,6 @@ class CliHelper
 
     # Add docs to list from Ceedling (docs/) and supporting projects (docs/<project>)
     { # Source path => docs/ destination path
-      'docs'                    => '.',
       'vendor/unity/docs'       => 'unity',
       'vendor/cmock/docs'       => 'cmock',
       'vendor/c_exception/docs' => 'c_exception'
@@ -380,17 +485,6 @@ class CliHelper
       end
     end
 
-    # Add docs to list from Ceedling plugins (docs/plugins)
-    glob = File.join( ceedling_root, 'plugins/**/README.md' )
-    listing = @file_wrapper.directory_listing( glob ) # Already case-insensitive
-    listing.each do |path|
-      # 'README.md' => '<name>.md' where name extracted from containing path
-      rename = path.split(/\\|\//)[-2] + '.md'
-      # For each Ceedling plugin readme, add to hash
-      dest = File.join( 'plugins', rename )
-      doc_files[ dest ] = path
-    end
-
     # Add licenses from Ceedling (docs/) and supporting projects (docs/<project>)
     { # Destination path => Source path
       '.'           => '.', # Ceedling
@@ -409,10 +503,28 @@ class CliHelper
       doc_files[ dest ] = filepath
     end
 
-    # Copy all documentation
-    doc_files.each_pair do |dest, src|
-      @actions._copy_file(src, File.join( docs_path, dest ), :force => true)
+    # Copy all individual documentation files gathered up
+    doc_files.each_pair do |_dest, src|
+      @actions._copy_file(src, File.join( dest, _dest ), :force => true )
+    end
+
+    # If present copy internl HTML documentation bundle (site-local/) to docs/ceedling/
+    site_local_path = File.join( ceedling_root, DOCS_SITE_LOCAL_PATH )
+    if @file_wrapper.directory?( site_local_path )
+      @actions._directory( site_local_path, docs_path_ceedling, :force => true )
+    else
+      @loginator.console( "Internal HTML documentation bundle not found", LogLabels::WARNING )
+      return
     end
+
+    ceedling_index_html_filepath = File.absolute_path( File.join( docs_path_ceedling, 'index.html' ) )
+    @loginator.console(
+      "\nCeedling documentation available at #{ceedling_index_html_filepath}",
+      LogLabels::DOCUMENTATION
+    )
+    
+    dest_abs = File.absolute_path( dest )
+    @loginator.console( " > All other documentation available at #{dest_abs}/\n" )
   end
 
 
@@ -509,4 +621,16 @@ class CliHelper
     end
   end
 
+
+  private
+
+  def project_name_banner(config)
+    name, _ = @config_walkinator.fetch_value( :project, :name, hash:config )
+    return nil if name.nil? || name.empty?
+
+    @reportinator.generate_banner(
+      @loginator.decorate( name.upcase, LogLabels::TITLE )
+    )
+  end
+
 end

data/bin/configinator.rb

@@ -1,17 +1,18 @@
 # =========================================================================
 #   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/constants'
 
 class Configinator
 
   constructor :config_walkinator, :projectinator, :mixinator
 
-  def loadinate(builtin_mixins:, filepath:nil, mixins:[], env:{}, silent:false)
+  def loadinate(builtin_mixins:, builtin_load_paths:[], filepath:nil, mixins:[], env:{}, silent:false)
     # Aliases for clarity
     cmdline_filepath = filepath
     cmdline_mixins = mixins || []
@@ -27,9 +28,35 @@ class Configinator
 
     # Remove any silly redundancies
     cfg_enabled_mixins.uniq!
+    # Append project directory then built-in load paths so precedence is:
+    #   user :load_paths → project directory → unity/targets
+    cfg_load_paths += [File.dirname(project_filepath)] + builtin_load_paths
     # Use absolute path to ensure proper deduplication
     cfg_load_paths.uniq! { |path| File.expand_path(path) }
-    cmdline_mixins.uniq!
+
+    # Parse sigils from each raw --mixin value to tag entries as file-based or inline YAML.
+    # This tagging happens before any validation or lookup so that each type is routed
+    # to the appropriate validator. Positional order is captured here in tagged_cmdline
+    # and must be preserved through the pipeline so that left-to-right merge semantics
+    # on the command line are honored (later entries win on scalar conflicts).
+    #
+    # Sigil conventions:
+    #   '=' prefix  → inline YAML string (strip the sigil, treat value as YAML content)
+    #   '@' prefix  → explicit file/name reference (strip the sigil, existing behavior)
+    #   no prefix   → file/name reference, backwards-compatible with existing usage
+    tagged_cmdline = cmdline_mixins.map do |m|
+      if    m.start_with?(MIXIN_SIGIL_INLINE_YAML) then {type: :yaml, value: m[1..]}
+      elsif m.start_with?(MIXIN_SIGIL_FILEPATH)    then {type: :file, value: m[1..]}
+      else                          {type: :file, value: m}
+      end
+    end
+
+    # Pull out the two streams for type-specific processing
+    cmdline_file_values = tagged_cmdline.select {|e| e[:type] == :file}.map {|e| e[:value]}
+    cmdline_yaml_values = tagged_cmdline.select {|e| e[:type] == :yaml}.map {|e| e[:value]}
+
+    # Deduplicate file values only; inline YAML is deduplicated later
+    cmdline_file_values.uniq!
 
     # Validate :cfg_load_paths from :mixins section of project configuration
     @projectinator.validate_mixin_load_paths( cfg_load_paths )
@@ -45,9 +72,9 @@ class Configinator
       raise 'Project configuration file section :mixins failed validation'
     end
 
-    # Validate command line mixins
+    # Validate only file-based cmdline entries; inline YAML is validated separately below
     if not @projectinator.validate_mixins(
-      mixins: cmdline_mixins,
+      mixins: cmdline_file_values,
       load_paths: cfg_load_paths,
       builtins: builtin_mixins,
       source: 'Mixin',
@@ -56,6 +83,9 @@ class Configinator
       raise 'Command line failed validation'
     end
 
+    # Validate inline YAML strings: must parse cleanly and produce a Hash
+    @mixinator.validate_cmdline_yaml_strings( cmdline_yaml_values )
+
     # Find mixins in project file among load paths or built-in mixins
     # Return ordered list of filepaths or built-in mixin names
     config_mixins = @projectinator.lookup_mixins(
@@ -65,14 +95,41 @@ class Configinator
       yaml_extension: yaml_ext
     )
 
-    # Find mixins from command line among load paths or built-in mixins
-    # Return ordered list of filepaths or built-in mixin names
-    cmdline_mixins = @projectinator.lookup_mixins(
-      mixins: cmdline_mixins,
+    # Pre-build config entries as tagged hashes carrying both the resolved path and
+    # the original :enabled name. This preserves the user-provided name for history
+    # traceability without losing the resolved path needed by the merge pipeline.
+    config_entries = cfg_enabled_mixins.zip(config_mixins).map do |(name, path)|
+      {'project configuration' => path, :_input => name}
+    end
+
+    # Resolve file-based names/paths to canonical filepaths (or built-in keys).
+    # Returns values in the same order as the input; zip them back into a hash for
+    # O(1) lookup when reconstructing positional order below.
+    resolved_file_values = @projectinator.lookup_mixins(
+      mixins: cmdline_file_values,
       load_paths: cfg_load_paths,
       builtins: builtin_mixins,
       yaml_extension: yaml_ext
     )
+    file_resolution_map = Hash[cmdline_file_values.zip(resolved_file_values)]
+
+    # Reconstruct the full cmdline sequence in original left-to-right order,
+    # replacing stripped file values with their resolved forms and tagging each
+    # entry with a source label that mixin() uses to select the load strategy.
+    # File entries that were deduplicated (absent from map after first use) are
+    # skipped — delete after first fetch enforces single-use per unique value.
+    cmdline_ordered = tagged_cmdline.each_with_object([]) do |e, arr|
+      if e[:type] == :yaml
+        # Inline YAML: source label 'command line (inline)' triggers load_string() in mixin()
+        # :_input carries the raw YAML string as the original user value for history traceability
+        arr << {'command line (inline)' => e[:value], :_input => e[:value]}
+      elsif (resolved = file_resolution_map[e[:value]])
+        # File/name: source label 'command line' triggers existing file/builtin dispatch in mixin()
+        # :_input carries the original user-provided value (before load-path resolution) for history
+        arr << {'command line' => resolved, :_input => e[:value]}
+        file_resolution_map.delete(e[:value])  # consume so duplicate raw values are skipped
+      end
+    end
 
     # Fetch CEEDLING_MIXIN_# environment variables
     # Sort into ordered list of hash tuples [{env variable => filepath}...]
@@ -81,14 +138,16 @@ class Configinator
 
     # Eliminate duplicate mixins and return list of mixins in merge order
     # [{source => filepath}...]
+    # cmdline_ordered is pre-tagged and positionally ordered; assemble_mixins preserves
+    # relative order within each tier (config → env → cmdline)
     mixins_assembled = @mixinator.assemble_mixins(
-      config: config_mixins,
+      config: config_entries,
       env: env_mixins,
-      cmdline: cmdline_mixins
+      cmdline: cmdline_ordered
     )
 
     # Merge mixins
-    @mixinator.merge( builtins:builtin_mixins, config:config, mixins:mixins_assembled )
+    @mixinator.mixin( builtins:builtin_mixins, config:config, mixins:mixins_assembled )
 
     return project_filepath, config
   end

data/bin/merginator.rb

@@ -0,0 +1,82 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require_relative 'recursive_merger'
+
+class Merginator
+
+  constructor :reportinator
+
+  def setup
+    # ...
+  end
+
+
+  def merge(config:, mixin:, warnings:)
+    # Find any incompatible merge values in config and mixin
+    validate = validate_merge( config:config, mixin:mixin, mismatches:warnings )
+
+    # Merge mixin into config using custom recursive logic that preserves
+    # priority order for both single values and lists. See RecursiveMerger
+    # for the full set of merge rules.
+    RecursiveMerger.merge!( config, mixin )
+
+    return validate
+  end
+
+  ### Private
+
+  private
+
+  # Recursive inspection of mergeable base config & mixin
+  def validate_merge(config:, mixin:, key_path:[], mismatches:)
+    # Track whether all matching hash key paths have matching value types
+    valid = true
+    
+    # Get all keys from both hashes
+    all_keys = (config.keys + mixin.keys).uniq
+    
+    all_keys.each do |key|
+      current_path = key_path + [key]
+      
+      # Skip if key doesn't exist in both hashes
+      next unless config.key?(key) && mixin.key?(key)
+      
+      config_value = config[key]
+      mixin_value = mixin[key]
+      
+      if config_value.is_a?(Hash) && mixin_value.is_a?(Hash)
+        # Recursively check nested hashes
+        sub_result = validate_merge(
+          config: config_value,
+          mixin: mixin_value,
+          key_path: current_path,
+          mismatches: mismatches
+        )
+
+        valid = false unless sub_result
+
+      # When the config value is already a list, merging any mixin value into it is allowed —
+      # RecursiveMerger handles all list combinations without type errors.
+      elsif !config_value.is_a?(Array)
+        # Compare types of non-hash values
+        unless config_value.class == mixin_value.class
+          # If mergeable values at key paths in common are not the same type, register this
+          valid = false
+          key_path_str = @reportinator.generate_config_walk( current_path )
+          warning = "Incompatible merge at key path #{key_path_str} ==> Project configuration has #{config_value.class} while Mixin has #{mixin_value.class}"
+ 
+          # Do not use `<<` as it is locally scoped
+          mismatches.push( warning )
+        end
+      end
+    end
+        
+    return valid
+  end
+
+end