ceedling 0.0.1

data/new_project_template/vendor/ceedling/lib/configurator_plugins.rb

@@ -0,0 +1,96 @@
+require 'constants'
+
+class ConfiguratorPlugins
+
+  constructor :stream_wrapper, :file_wrapper, :system_wrapper
+
+  def setup
+    @rake_plugins   = []
+    @script_plugins = []
+  end
+
+  
+  def add_load_paths(config)
+    config[:plugins][:load_paths].each do |root|
+      @system_wrapper.add_load_path( root ) if ( not @file_wrapper.directory_listing( File.join( root, '*.rb' ) ).empty? )
+    
+      config[:plugins][:enabled].each do |plugin|
+        path = File.join( root, plugin )
+        @system_wrapper.add_load_path( path ) if ( not @file_wrapper.directory_listing( File.join( path, '*.rb' ) ).empty? )
+      end
+    end
+  end
+  
+  
+  # gather up and return .rake filepaths that exist on-disk
+  def find_rake_plugins(config)
+    plugins_with_path = []
+    
+    config[:plugins][:load_paths].each do |root|
+      config[:plugins][:enabled].each do |plugin|
+        rake_plugin_path = File.join(root, plugin, "#{plugin}.rake")
+        if (@file_wrapper.exist?(rake_plugin_path))
+          plugins_with_path << rake_plugin_path
+          @rake_plugins << plugin
+        end
+      end
+    end
+    
+    return plugins_with_path
+  end
+
+
+  # gather up and return just names of .rb classes that exist on-disk
+  def find_script_plugins(config)
+    config[:plugins][:load_paths].each do |root|
+      config[:plugins][:enabled].each do |plugin|
+        script_plugin_path = File.join(root, plugin, "#{plugin}.rb")
+        @script_plugins << plugin if @file_wrapper.exist?(script_plugin_path)
+      end
+    end
+    
+    return @script_plugins 
+  end
+  
+  
+  # gather up and return configuration .yml filepaths that exist on-disk
+  def find_config_plugins(config)
+    plugins_with_path = []
+    
+    config[:plugins][:load_paths].each do |root|
+      config[:plugins][:enabled].each do |plugin|
+        config_plugin_path = File.join(root, plugin, "#{plugin}.yml")
+        plugins_with_path << config_plugin_path if @file_wrapper.exist?(config_plugin_path)
+      end
+    end
+    
+    return plugins_with_path    
+  end
+
+  
+  # gather up and return default .yml filepaths that exist on-disk
+  def find_plugin_defaults(config)
+    defaults_with_path = []
+    
+    config[:plugins][:load_paths].each do |root|
+      config[:plugins][:enabled].each do |plugin|
+        default_path = File.join(root, plugin, 'defaults.yml')
+        defaults_with_path << default_path if @file_wrapper.exist?(default_path)
+      end
+    end
+
+    return defaults_with_path    
+  end
+  
+  
+  def validate_plugins(enabled_plugins)
+    missing_plugins = Set.new(enabled_plugins) - Set.new(@rake_plugins) - Set.new(@script_plugins)
+    
+    missing_plugins.each do |plugin|
+      @stream_wrapper.stdout_puts.stderr_puts("ERROR: Ceedling plugin '#{plugin}' contains no rake or ruby class entry point. (Misspelled or missing files?)")
+    end
+    
+    raise if (missing_plugins.size > 0)
+  end
+
+end

data/new_project_template/vendor/ceedling/lib/configurator_setup.rb

@@ -0,0 +1,114 @@
+
+# add sort-ability to symbol so we can order keys array in hash for test-ability 
+class Symbol
+  include Comparable
+
+  def <=>(other)
+    self.to_s <=> other.to_s
+  end
+end
+
+
+class ConfiguratorSetup
+  
+  constructor :configurator_builder, :configurator_validator
+  
+  
+  def build_project_config(config)
+    # convert config object to flattened hash
+    new_config = @configurator_builder.flattenify(config)
+
+    # flesh out config
+    @configurator_builder.clean(new_config)
+    
+    # add to hash values we build up from configuration & file system contents
+    new_config.merge!(@configurator_builder.set_build_paths(new_config))
+    new_config.merge!(@configurator_builder.set_force_build_filepaths(new_config))
+    new_config.merge!(@configurator_builder.set_rakefile_components(new_config))
+    new_config.merge!(@configurator_builder.set_library_build_info_filepaths(new_config))
+    new_config.merge!(@configurator_builder.set_release_target(new_config))
+    new_config.merge!(@configurator_builder.collect_project_options(new_config))
+    new_config.merge!(@configurator_builder.collect_environment_variables(config))
+    
+    # iterate through all entries in paths section and expand any & all globs to actual paths
+    new_config.merge!(@configurator_builder.expand_all_path_globs(new_config))
+    
+    new_config.merge!(@configurator_builder.collect_source_and_include_paths(new_config))
+    new_config.merge!(@configurator_builder.collect_source_include_vendor_paths(new_config))
+    new_config.merge!(@configurator_builder.collect_test_support_source_include_paths(new_config))
+    new_config.merge!(@configurator_builder.collect_test_support_source_include_vendor_paths(new_config))
+    new_config.merge!(@configurator_builder.collect_tests(new_config))
+    new_config.merge!(@configurator_builder.collect_assembly(new_config))
+    new_config.merge!(@configurator_builder.collect_source(new_config))
+    new_config.merge!(@configurator_builder.collect_headers(new_config))
+    new_config.merge!(@configurator_builder.collect_all_existing_compilation_input(new_config))
+    new_config.merge!(@configurator_builder.collect_test_and_vendor_defines(new_config))
+    new_config.merge!(@configurator_builder.collect_release_and_vendor_defines(new_config))
+    new_config.merge!(@configurator_builder.collect_release_artifact_extra_link_objects(new_config))
+    new_config.merge!(@configurator_builder.collect_test_fixture_extra_link_objects(new_config))
+
+    return new_config
+  end
+
+  
+  def build_constants_and_accessors(config, context)
+    @configurator_builder.build_global_constants(config)
+    @configurator_builder.build_accessor_methods(config, context)
+  end
+  
+  
+  def validate_required_sections(config)
+    validation = []
+    validation << @configurator_validator.exists?(config, :project)
+    validation << @configurator_validator.exists?(config, :paths)
+
+    return false if (validation.include?(false))
+    return true
+  end
+
+  def validate_required_section_values(config)
+    validation = []
+    validation << @configurator_validator.exists?(config, :project, :build_root)
+    validation << @configurator_validator.exists?(config, :paths, :test)
+    validation << @configurator_validator.exists?(config, :paths, :source)
+
+    return false if (validation.include?(false))
+    return true
+  end
+
+  def validate_paths(config)
+    validation = []
+
+    validation << @configurator_validator.validate_filepath(config, {:search_system_path => false}, :project, :build_root)
+    validation << @configurator_validator.validate_filepath(config, {:search_system_path => false}, :cmock, :unity_helper) if config[:cmock][:unity_helper]
+
+    config[:project][:options_paths].each do |path|
+      validation << @configurator_validator.validate_filepath_simple( path, :project, :options_paths )
+    end
+
+    config[:plugins][:load_paths].each do |path|
+      validation << @configurator_validator.validate_filepath_simple( path, :plugins, :load_paths )
+    end
+
+    config[:paths].keys.sort.each do |key|
+      validation << @configurator_validator.validate_path_list(config, :paths, key)
+    end
+
+    return false if (validation.include?(false))
+    return true
+  end
+  
+  def validate_tools(config)
+    validation = []
+
+    config[:tools].keys.sort.each do |key|
+      validation << @configurator_validator.exists?(config, :tools, key, :executable)
+      validation << @configurator_validator.validate_filepath(config, {:search_system_path => true}, :tools, key, :executable)
+      validation << @configurator_validator.validate_tool_stderr_redirect(config, :tools, key)
+    end
+
+    return false if (validation.include?(false))
+    return true
+  end
+
+end

data/new_project_template/vendor/ceedling/lib/configurator_validator.rb

@@ -0,0 +1,154 @@
+require 'constants'
+require 'tool_executor'    # for argument replacement pattern
+require 'file_path_utils'  # for glob handling class methods
+
+
+class ConfiguratorValidator
+  
+  constructor :file_wrapper, :stream_wrapper, :system_wrapper
+
+  # walk into config hash verify existence of data at key depth
+  def exists?(config, *keys)
+    hash  = retrieve_value(config, keys)
+    exist = !hash[:value].nil?
+
+    if (not exist)
+      # no verbosity checking since this is lowest level anyhow & verbosity checking depends on configurator
+      @stream_wrapper.stderr_puts("ERROR: Required config file entry #{format_key_sequence(keys, hash[:depth])} does not exist.")    
+    end
+    
+    return exist
+  end
+
+
+  # walk into config hash. verify directory path(s) at given key depth
+  def validate_path_list(config, *keys)
+    hash = retrieve_value(config, keys)
+    list = hash[:value]
+
+    # return early if we couldn't walk into hash and find a value
+    return false if (list.nil?)
+
+    path_list = []
+    exist = true
+    
+    case list
+      when String then path_list << list
+      when Array  then path_list =  list
+    end
+    
+    path_list.each do |path|
+      base_path = FilePathUtils::extract_path(path) # lop off add/subtract notation & glob specifiers
+      
+      if (not @file_wrapper.exist?(base_path))
+        # no verbosity checking since this is lowest level anyhow & verbosity checking depends on configurator
+        @stream_wrapper.stderr_puts("ERROR: Config path #{format_key_sequence(keys, hash[:depth])}['#{base_path}'] does not exist on disk.") 
+        exist = false
+      end 
+    end
+    
+    return exist
+  end
+
+  
+  # simple path verification
+  def validate_filepath_simple(path, *keys)
+    validate_path = path
+    
+    if (not @file_wrapper.exist?(validate_path))
+      # no verbosity checking since this is lowest level anyhow & verbosity checking depends on configurator
+      @stream_wrapper.stderr_puts("ERROR: Config path '#{validate_path}' associated with #{format_key_sequence(keys, keys.size)} does not exist on disk.") 
+      return false
+    end 
+    
+    return true
+  end
+
+ 
+  # walk into config hash. verify specified file exists.
+  def validate_filepath(config, options, *keys)
+    hash = retrieve_value(config, keys)
+    filepath = hash[:value]
+
+    # return early if we couldn't walk into hash and find a value
+    return false if (filepath.nil?)
+
+    # skip everything if we've got an argument replacement pattern
+    return true if (filepath =~ TOOL_EXECUTOR_ARGUMENT_REPLACEMENT_PATTERN)
+    
+    # if there's no path included, verify file exists somewhere in system search paths
+    if (not filepath.include?('/') and options[:search_system_path])
+      exists = false
+      
+      @system_wrapper.search_paths.each do |path|
+        if (@file_wrapper.exist?(File.join(path, filepath)))
+          exists = true
+          break
+        end
+      end
+      
+      if (not exists)
+        # no verbosity checking since this is lowest level anyhow & verbosity checking depends on configurator
+        @stream_wrapper.stderr_puts("ERROR: Config filepath #{format_key_sequence(keys, hash[:depth])}['#{filepath}'] does not exist in system search paths.") 
+        return false        
+      end
+      
+    # if there is a path included, check that explicit filepath exists
+    else
+      if (not @file_wrapper.exist?(filepath))
+        # no verbosity checking since this is lowest level anyhow & verbosity checking depends on configurator
+        @stream_wrapper.stderr_puts("ERROR: Config filepath #{format_key_sequence(keys, hash[:depth])}['#{filepath}'] does not exist on disk.") 
+        return false
+      end      
+    end
+
+    return true
+  end
+  
+  def validate_tool_stderr_redirect(config, tools, tool)
+    redirect = config[tools][tool][:stderr_redirect]
+    if (redirect.class == Symbol)
+      # map constants and force to array of strings for runtime universality across ruby versions
+      if (not StdErrRedirect.constants.map{|constant| constant.to_s}.include?(redirect.to_s.upcase))
+        error = "ERROR: [:#{tools}][:#{tool}][:stderr_redirect][:#{redirect}] is not a recognized option " +
+                "{#{StdErrRedirect.constants.map{|constant| ':' + constant.to_s.downcase}.join(', ')}}."
+        @stream_wrapper.stderr_puts(error) 
+        return false        
+      end
+    end
+    
+    return true
+  end
+  
+  private #########################################
+  
+  
+  def retrieve_value(config, keys)
+    value = nil
+    hash  = config
+    depth = 0
+
+    # walk into hash & extract value at requested key sequence
+    keys.each do |symbol|
+      depth += 1
+      if (not hash[symbol].nil?)
+        hash  = hash[symbol]
+        value = hash
+      else
+        value = nil
+        break
+      end
+    end
+    
+    return {:value => value, :depth => depth}
+  end
+
+
+  def format_key_sequence(keys, depth)
+    walked_keys    = keys.slice(0, depth)
+    formatted_keys = walked_keys.map{|key| "[:#{key.to_s}]"}
+    
+    return formatted_keys.join
+  end
+  
+end

data/new_project_template/vendor/ceedling/lib/constants.rb

@@ -0,0 +1,66 @@
+
+class Verbosity
+  SILENT      = 0  # as silent as possible (though there are some messages that must be spit out)
+  ERRORS      = 1  # only errors
+  COMPLAIN    = 2  # spit out errors and warnings/notices
+  NORMAL      = 3  # errors, warnings/notices, standard status messages
+  OBNOXIOUS   = 4  # all messages including extra verbose output (used for lite debugging / verification)
+  DEBUG       = 5  # special extra verbose output for hardcore debugging
+end
+
+
+class TestResultsSanityChecks
+  NONE      = 0  # no sanity checking of test results
+  NORMAL    = 1  # perform non-problematic checks
+  THOROUGH  = 2  # perform checks that require inside knowledge of system workings
+end
+
+
+class StdErrRedirect
+  NONE = :none
+  AUTO = :auto
+  WIN  = :win
+  UNIX = :unix
+  TCSH = :tcsh
+end
+
+CEXCEPTION_ROOT_PATH = 'c_exception'
+CEXCEPTION_LIB_PATH  = "#{CEXCEPTION_ROOT_PATH}/lib"
+CEXCEPTION_C_FILE    = 'CException.c'
+CEXCEPTION_H_FILE    = 'CException.h'
+
+UNITY_ROOT_PATH        = 'unity'
+UNITY_LIB_PATH         = "#{UNITY_ROOT_PATH}/src"
+UNITY_C_FILE           = 'unity.c'
+UNITY_H_FILE           = 'unity.h'
+UNITY_INTERNALS_H_FILE = 'unity_internals.h'
+
+CMOCK_ROOT_PATH = 'cmock'
+CMOCK_LIB_PATH  = "#{CMOCK_ROOT_PATH}/src"
+CMOCK_C_FILE    = 'cmock.c'
+CMOCK_H_FILE    = 'cmock.h'
+
+
+DEFAULT_CEEDLING_MAIN_PROJECT_FILE = 'project.yml' # main project file
+DEFAULT_CEEDLING_USER_PROJECT_FILE = 'user.yml'    # supplemental user config file
+
+INPUT_CONFIGURATION_CACHE_FILE     = 'input.yml'   # input configuration file dump
+
+
+TEST_ROOT_NAME    = 'test'
+TEST_TASK_ROOT    = TEST_ROOT_NAME + ':'
+TEST_CONTEXT      = TEST_ROOT_NAME.to_sym
+
+RELEASE_ROOT_NAME = 'release'
+RELEASE_TASK_ROOT = RELEASE_ROOT_NAME + ':'
+RELEASE_CONTEXT   = RELEASE_ROOT_NAME.to_sym
+
+
+RUBY_STRING_REPLACEMENT_PATTERN = /#\{.+\}/
+RUBY_EVAL_REPLACEMENT_PATTERN   = /^\{(.+)\}$/
+TOOL_EXECUTOR_ARGUMENT_REPLACEMENT_PATTERN = /(\$\{(\d+)\})/
+
+NULL_FILE_PATH = '/dev/null'
+
+TESTS_BASE_PATH   = 'tests'
+RELEASE_BASE_PATH = 'release'