class ConfiguratorBuilder

Public Instance Methods

build_accessor_methods(config, context) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 25
def build_accessor_methods(config, context)
  config.each_pair do |key, value|
    # fill configurator object with accessor methods
    eval("def #{key.to_s.downcase}() return @project_config_hash[:#{key.to_s}] end", context)
  end
end
build_global_constants(config) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 14
def build_global_constants(config)
  config.each_pair do |key, value|
    formatted_key = key.to_s.upcase
    # undefine global constant if it already exists
    Object.send(:remove_const, formatted_key.to_sym) if @system_wrapper.constants_include?(formatted_key)
    # create global constant
    Object.module_eval("#{formatted_key} = value")
  end
end
clean(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 74
def clean(in_hash)
  # ensure that include files inserted into test runners have file extensions & proper ones at that
  in_hash[:test_runner_includes].map!{|include| include.ext(in_hash[:extension_header])}
end
collect_all_existing_compilation_input(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 354
def collect_all_existing_compilation_input(in_hash)
  all_input = @file_wrapper.instantiate_file_list

  paths =
    in_hash[:collection_paths_test] +
    in_hash[:collection_paths_support] +
    in_hash[:collection_paths_source] +
    in_hash[:collection_paths_include] +
    [File.join(in_hash[:unity_vendor_path], UNITY_LIB_PATH)]

  paths << File.join(in_hash[:cexception_vendor_path], CEXCEPTION_LIB_PATH) if (in_hash[:project_use_exceptions])
  paths << File.join(in_hash[:cmock_vendor_path],      CMOCK_LIB_PATH)      if (in_hash[:project_use_mocks])

  paths.each do |path|
    all_input.include( File.join(path, "*#{in_hash[:extension_header]}") )
    if File.exists?(path) and not File.directory?(path)
      all_input.include( path )
    else
      all_input.include( File.join(path, "*#{in_hash[:extension_source]}") )
      all_input.include( File.join(path, "*#{in_hash[:extension_assembly]}") ) if (defined?(TEST_BUILD_USE_ASSEMBLY) && TEST_BUILD_USE_ASSEMBLY)
    end
  end

  @file_system_utils.revise_file_list( all_input, in_hash[:files_test] )
  @file_system_utils.revise_file_list( all_input, in_hash[:files_support] )
  @file_system_utils.revise_file_list( all_input, in_hash[:files_source] )
  @file_system_utils.revise_file_list( all_input, in_hash[:files_include] )
  # finding assembly files handled explicitly through other means

  return {:collection_all_existing_compilation_input => all_input}
end
collect_assembly(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 272
def collect_assembly(in_hash)
  all_assembly = @file_wrapper.instantiate_file_list

  return {:collection_all_assembly => all_assembly} if ((not in_hash[:release_build_use_assembly]) && (not in_hash[:test_build_use_assembly]))

  # Sprinkle in all assembly files we can find in the source folders
  in_hash[:collection_paths_source].each do |path|
    all_assembly.include( File.join(path, "*#{in_hash[:extension_assembly]}") )
  end

  # Also add all assembly files we can find in the support folders
  in_hash[:collection_paths_support].each do |path|
    all_assembly.include( File.join(path, "*#{in_hash[:extension_assembly]}") )
  end

  # Also add files that we are explicitly adding via :files:assembly: section
  @file_system_utils.revise_file_list( all_assembly, in_hash[:files_assembly] )

  return {:collection_all_assembly => all_assembly}
end
collect_headers(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 309
def collect_headers(in_hash)
  all_headers = @file_wrapper.instantiate_file_list

  paths =
    in_hash[:collection_paths_test] +
    in_hash[:collection_paths_support] +
    in_hash[:collection_paths_source] +
    in_hash[:collection_paths_include]

  paths.each do |path|
    all_headers.include( File.join(path, "*#{in_hash[:extension_header]}") )
  end

  @file_system_utils.revise_file_list( all_headers, in_hash[:files_include] )

  return {:collection_all_headers => all_headers}
end
collect_project_options(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 182
def collect_project_options(in_hash)
  options = []

  in_hash[:project_options_paths].each do |path|
    options << @file_wrapper.directory_listing( File.join(path, '*.yml') )
  end

  return {
    :collection_project_options => options.flatten
    }
end
collect_release_and_vendor_defines(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 410
def collect_release_and_vendor_defines(in_hash)
  release_defines = in_hash[:defines_release].clone

  release_defines.concat(in_hash[:cexception_defines]) if (in_hash[:project_use_exceptions])

  return {:collection_defines_release_and_vendor => release_defines}
end
collect_release_existing_compilation_input(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 328
def collect_release_existing_compilation_input(in_hash)
  release_input = @file_wrapper.instantiate_file_list

  paths =
    in_hash[:collection_paths_source] +
    in_hash[:collection_paths_include]

  paths << File.join(in_hash[:cexception_vendor_path], CEXCEPTION_LIB_PATH) if (in_hash[:project_use_exceptions])

  paths.each do |path|
    release_input.include( File.join(path, "*#{in_hash[:extension_header]}") )
    if File.exists?(path) and not File.directory?(path)
      release_input.include( path )
    else
      release_input.include( File.join(path, "*#{in_hash[:extension_source]}") )
    end
  end

  @file_system_utils.revise_file_list( release_input, in_hash[:files_source] )
  @file_system_utils.revise_file_list( release_input, in_hash[:files_include] )
  # finding assembly files handled explicitly through other means

  return {:collection_release_existing_compilation_input => release_input}
end
collect_source(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 294
def collect_source(in_hash)
  all_source = @file_wrapper.instantiate_file_list
  in_hash[:collection_paths_source].each do |path|
    if File.exists?(path) and not File.directory?(path)
      all_source.include( path )
    else
      all_source.include( File.join(path, "*#{in_hash[:extension_source]}") )
    end
  end
  @file_system_utils.revise_file_list( all_source, in_hash[:files_source] )

  return {:collection_all_source => all_source}
end
collect_source_and_include_paths(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 213
def collect_source_and_include_paths(in_hash)
  return {
    :collection_paths_source_and_include =>
      ( in_hash[:collection_paths_source] +
        in_hash[:collection_paths_include] ).select {|x| File.directory?(x)}
    }
end
collect_source_include_vendor_paths(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 222
def collect_source_include_vendor_paths(in_hash)
  extra_paths = []
  extra_paths << File.join(in_hash[:cexception_vendor_path], CEXCEPTION_LIB_PATH) if (in_hash[:project_use_exceptions])

  return {
    :collection_paths_source_include_vendor =>
      in_hash[:collection_paths_source_and_include] +
      extra_paths
    }
end
collect_test_and_vendor_defines(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 401
def collect_test_and_vendor_defines(in_hash)
  defines = in_hash[:defines_test].clone
  vendor_defines = get_vendor_defines(in_hash)
  defines.concat(vendor_defines) if vendor_defines

  return {:collection_defines_test_and_vendor => defines}
end
collect_test_support_source_include_paths(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 234
def collect_test_support_source_include_paths(in_hash)
  return {
    :collection_paths_test_support_source_include =>
      (in_hash[:collection_paths_test] +
      in_hash[:collection_paths_support] +
      in_hash[:collection_paths_source] +
      in_hash[:collection_paths_include] ).select {|x| File.directory?(x)}
    }
end
collect_test_support_source_include_vendor_paths(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 250
def collect_test_support_source_include_vendor_paths(in_hash)
  return {
    :collection_paths_test_support_source_include_vendor =>
      get_vendor_paths(in_hash) +
      in_hash[:collection_paths_test_support_source_include]
    }
end
collect_tests(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 259
def collect_tests(in_hash)
  all_tests = @file_wrapper.instantiate_file_list

  in_hash[:collection_paths_test].each do |path|
    all_tests.include( File.join(path, "#{in_hash[:project_test_file_prefix]}*#{in_hash[:extension_source]}") )
  end

  @file_system_utils.revise_file_list( all_tests, in_hash[:files_test] )

  return {:collection_all_tests => all_tests}
end
collect_vendor_defines(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 396
def collect_vendor_defines(in_hash)
  return {:collection_defines_vendor => get_vendor_defines(in_hash)}
end
collect_vendor_paths(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 245
def collect_vendor_paths(in_hash)
  return {:collection_paths_vendor => get_vendor_paths(in_hash)}
end
expand_all_path_globs(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 195
def expand_all_path_globs(in_hash)
  out_hash = {}
  path_keys = []

  in_hash.each_key do |key|
    next if (not key.to_s[0..4] == 'paths')
    path_keys << key
  end

  # sorted to provide assured order of traversal in test calls on mocks
  path_keys.sort.each do |key|
    out_hash["collection_#{key.to_s}".to_sym] = @file_system_utils.collect_paths( in_hash[key] )
  end

  return out_hash
end
flattenify(config) click to toggle source

create a flattened hash from the original configuration structure

# File lib/ceedling/configurator_builder.rb, line 34
def flattenify(config)
  new_hash = {}

  config.each_key do | parent |

    # gracefully handle empty top-level entries
    next if (config[parent].nil?)

    case config[parent]
    when Array
      config[parent].each do |hash|
        key = "#{parent.to_s.downcase}_#{hash.keys[0].to_s.downcase}".to_sym
        new_hash[key] = hash[hash.keys[0]]
      end
    when Hash
      config[parent].each_pair do | child, value |
        key = "#{parent.to_s.downcase}_#{child.to_s.downcase}".to_sym
        new_hash[key] = value
      end
    # handle entries with no children, only values
    else
      new_hash["#{parent.to_s.downcase}".to_sym] = config[parent]
    end

  end

  return new_hash
end
get_vendor_defines(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 387
def get_vendor_defines(in_hash)
  defines = in_hash[:unity_defines].clone
  defines.concat(in_hash[:cmock_defines])      if (in_hash[:project_use_mocks])
  defines.concat(in_hash[:cexception_defines]) if (in_hash[:project_use_exceptions])

  return defines
end
populate_defaults(config, defaults) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 64
def populate_defaults(config, defaults)
  defaults.keys.sort.each do |section|
    defaults[section].keys.sort.each do |entry|
      config[section] = {} if config[section].nil?
      config[section][entry] = defaults[section][entry].deep_clone if (config[section][entry].nil?)
    end
  end
end
set_build_paths(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 80
def set_build_paths(in_hash)
  out_hash = {}

  project_build_artifacts_root = File.join(in_hash[:project_build_root], 'artifacts')
  project_build_tests_root     = File.join(in_hash[:project_build_root], TESTS_BASE_PATH)
  project_build_release_root   = File.join(in_hash[:project_build_root], RELEASE_BASE_PATH)

  paths = [
    [:project_build_artifacts_root,  project_build_artifacts_root, true ],
    [:project_build_tests_root,      project_build_tests_root,     true ],
    [:project_build_release_root,    project_build_release_root,   in_hash[:project_release_build] ],

    [:project_test_artifacts_path,            File.join(project_build_artifacts_root, TESTS_BASE_PATH), true ],
    [:project_test_runners_path,              File.join(project_build_tests_root, 'runners'),           true ],
    [:project_test_results_path,              File.join(project_build_tests_root, 'results'),           true ],
    [:project_test_build_output_path,         File.join(project_build_tests_root, 'out'),               true ],
    [:project_test_build_output_asm_path,     File.join(project_build_tests_root, 'out', 'asm'),        true ],
    [:project_test_build_output_c_path,       File.join(project_build_tests_root, 'out', 'c'),          true ],
    [:project_test_build_cache_path,          File.join(project_build_tests_root, 'cache'),             true ],
    [:project_test_dependencies_path,         File.join(project_build_tests_root, 'dependencies'),      true ],

    [:project_release_artifacts_path,         File.join(project_build_artifacts_root, RELEASE_BASE_PATH), in_hash[:project_release_build] ],
    [:project_release_build_cache_path,       File.join(project_build_release_root, 'cache'),             in_hash[:project_release_build] ],
    [:project_release_build_output_path,      File.join(project_build_release_root, 'out'),               in_hash[:project_release_build] ],
    [:project_release_build_output_asm_path,  File.join(project_build_release_root, 'out', 'asm'),        in_hash[:project_release_build] ],
    [:project_release_build_output_c_path,    File.join(project_build_release_root, 'out', 'c'),          in_hash[:project_release_build] ],
    [:project_release_dependencies_path,      File.join(project_build_release_root, 'dependencies'),      in_hash[:project_release_build] ],

    [:project_log_path,   File.join(in_hash[:project_build_root], 'logs'), true ],
    [:project_temp_path,  File.join(in_hash[:project_build_root], 'temp'), true ],

    [:project_test_preprocess_includes_path,  File.join(project_build_tests_root, 'preprocess/includes'), in_hash[:project_use_test_preprocessor] ],
    [:project_test_preprocess_files_path,     File.join(project_build_tests_root, 'preprocess/files'),    in_hash[:project_use_test_preprocessor] ],
  ]

  out_hash[:project_build_paths] = []

  # fetch already set mock path
  out_hash[:project_build_paths] << in_hash[:cmock_mock_path] if (in_hash[:project_use_mocks])

  paths.each do |path|
    build_path_name          = path[0]
    build_path               = path[1]
    build_path_add_condition = path[2]

    # insert path into build paths if associated with true condition
    out_hash[:project_build_paths] << build_path if build_path_add_condition
    # set path symbol name and path for each entry in paths array
    out_hash[build_path_name] = build_path
  end

  return out_hash
end
set_force_build_filepaths(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 135
def set_force_build_filepaths(in_hash)
  out_hash = {}

  out_hash[:project_test_force_rebuild_filepath]    = File.join( in_hash[:project_test_dependencies_path], 'force_build' )
  out_hash[:project_release_force_rebuild_filepath] = File.join( in_hash[:project_release_dependencies_path], 'force_build' ) if (in_hash[:project_release_build])

  return out_hash
end
set_rakefile_components(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 145
def set_rakefile_components(in_hash)
  out_hash = {
    :project_rakefile_component_files =>
      [File.join(CEEDLING_LIB, 'ceedling', 'tasks_base.rake'),
       File.join(CEEDLING_LIB, 'ceedling', 'tasks_filesystem.rake'),
       File.join(CEEDLING_LIB, 'ceedling', 'tasks_tests.rake'),
       File.join(CEEDLING_LIB, 'ceedling', 'tasks_vendor.rake'),
       File.join(CEEDLING_LIB, 'ceedling', 'rules_tests.rake')]}

  out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'ceedling', 'rules_cmock.rake') if (in_hash[:project_use_mocks])
  out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'ceedling', 'rules_preprocess.rake') if (in_hash[:project_use_test_preprocessor])
  out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'ceedling', 'rules_tests_deep_dependencies.rake') if (in_hash[:project_use_deep_dependencies])
  out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'ceedling', 'tasks_tests_deep_dependencies.rake') if (in_hash[:project_use_deep_dependencies])

  out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'ceedling', 'rules_release_deep_dependencies.rake') if (in_hash[:project_release_build] and in_hash[:project_use_deep_dependencies])
  out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'ceedling', 'rules_release.rake') if (in_hash[:project_release_build])
  out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'ceedling', 'tasks_release_deep_dependencies.rake') if (in_hash[:project_release_build] and in_hash[:project_use_deep_dependencies])
  out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'ceedling', 'tasks_release.rake') if (in_hash[:project_release_build])

  return out_hash
end
set_release_target(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 168
def set_release_target(in_hash)
  return {} if (not in_hash[:project_release_build])

  release_target_file = ((in_hash[:release_build_output].nil?) ? (DEFAULT_RELEASE_TARGET_NAME.ext(in_hash[:extension_executable])) : in_hash[:release_build_output])
  release_map_file    = ((in_hash[:release_build_output].nil?) ? (DEFAULT_RELEASE_TARGET_NAME.ext(in_hash[:extension_map])) : in_hash[:release_build_output].ext(in_hash[:extension_map]))

  return {
    # tempted to make a helper method in file_path_utils? stop right there, pal. you'll introduce a cyclical dependency
    :project_release_build_target => File.join(in_hash[:project_build_release_root], release_target_file),
    :project_release_build_map    => File.join(in_hash[:project_build_release_root], release_map_file)
    }
end

Private Instance Methods

get_vendor_paths(in_hash) click to toggle source
# File lib/ceedling/configurator_builder.rb, line 465
def get_vendor_paths(in_hash)
  vendor_paths = []
  vendor_paths << File.join(in_hash[:unity_vendor_path],      UNITY_LIB_PATH)
  vendor_paths << File.join(in_hash[:cexception_vendor_path], CEXCEPTION_LIB_PATH) if (in_hash[:project_use_exceptions])
  vendor_paths << File.join(in_hash[:cmock_vendor_path],      CMOCK_LIB_PATH)      if (in_hash[:project_use_mocks])
  vendor_paths << in_hash[:cmock_mock_path]                                        if (in_hash[:project_use_mocks])

  return vendor_paths
end