RubyGems - ceedling - Versions diffs - 0.9.0 → 1.0.1 - Mend

ceedling 0.9.0 → 1.0.1

Files changed (1282) hide show

data/new_project_template/vendor/ceedling/lib/test_includes_extractor.rb DELETED Viewed

@@ -1,81 +0,0 @@
-class TestIncludesExtractor
-  constructor :configurator, :yaml_wrapper, :file_wrapper
-  def setup
-    @includes  = {}
-    @mocks     = {}
-  end
-  # for includes_list file, slurp up array from yaml file and sort & store includes
-  def parse_includes_list(includes_list)
-    gather_and_store_includes( includes_list, @yaml_wrapper.load(includes_list) )
-  end
-  # open, scan for, and sort & store includes of test file
-  def parse_test_file(test)
-    gather_and_store_includes( test, extract_from_file(test) )
-  end
-  # mocks with no file extension
-  def lookup_raw_mock_list(test)
-    file_key = form_file_key(test)
-    return [] if @mocks[file_key].nil?
-    return @mocks[file_key]
-  end
-  # includes with file extension
-  def lookup_includes_list(file)
-    file_key = form_file_key(file)
-    return [] if (@includes[file_key]).nil?
-    return @includes[file_key]
-  end
-  private #################################
-  def form_file_key(filepath)
-    return File.basename(filepath).to_sym
-  end
-  def extract_from_file(file)
-    includes = []
-    header_extension = @configurator.extension_header
-    contents = @file_wrapper.read(file)
-    # remove line comments
-    contents = contents.gsub(/\/\/.*$/, '')
-    # remove block comments
-    contents = contents.gsub(/\/\*.*?\*\//m, '')
-    contents.split("\n").each do |line|
-      # look for include statement
-      scan_results = line.scan(/#include\s+\"\s*(.+#{'\\'+header_extension})\s*\"/)
-      includes << scan_results[0][0] if (scan_results.size > 0)
-    end
-    return includes.uniq
-  end
-  def gather_and_store_includes(file, includes)
-    mock_prefix      = @configurator.cmock_mock_prefix
-    header_extension = @configurator.extension_header
-    file_key         = form_file_key(file)
-    @mocks[file_key] = []
-    # add includes to lookup hash
-    @includes[file_key] = includes
-    includes.each do |include_file|
-      # check if include is a mock
-      scan_results = include_file.scan(/(#{mock_prefix}.+)#{'\\'+header_extension}/)
-      # add mock to lookup hash
-      @mocks[file_key] << scan_results[0][0] if (scan_results.size > 0)
-    end
-  end
-end

data/new_project_template/vendor/ceedling/lib/test_invoker.rb DELETED Viewed

@@ -1,97 +0,0 @@
-require 'constants'
-class TestInvoker
-  attr_reader :sources, :tests, :mocks
-  constructor :configurator,
-              :test_invoker_helper,
-              :plugin_manager,
-              :streaminator,
-              :preprocessinator,
-              :task_invoker,
-              :dependinator,
-              :project_config_manager,
-              :build_invoker_utils,
-              :file_path_utils,
-              :file_wrapper
-  def setup
-    @sources = []
-    @tests   = []
-    @mocks   = []
-  end
-  def setup_and_invoke(tests, context=TEST_SYM, options={:force_run => true})
-    @tests = tests
-    @project_config_manager.process_test_config_change
-    @tests.each do |test|
-      # announce beginning of test run
-      header = "Test '#{File.basename(test)}'"
-      @streaminator.stdout_puts("\n\n#{header}\n#{'-' * header.length}")
-      begin
-        @plugin_manager.pre_test
-        # collect up test fixture pieces & parts
-        runner       = @file_path_utils.form_runner_filepath_from_test( test )
-        mock_list    = @preprocessinator.preprocess_test_and_invoke_test_mocks( test )
-        sources      = @test_invoker_helper.extract_sources( test )
-        extras       = @configurator.collection_test_fixture_extra_link_objects
-        core         = [test] + mock_list + sources
-        objects      = @file_path_utils.form_test_build_objects_filelist( [runner] + core + extras )
-        results_pass = @file_path_utils.form_pass_results_filepath( test )
-        results_fail = @file_path_utils.form_fail_results_filepath( test )
-        # clean results files so we have a missing file with which to kick off rake's dependency rules
-        @test_invoker_helper.clean_results( {:pass => results_pass, :fail => results_fail}, options )
-        # load up auxiliary dependencies so deep changes cause rebuilding appropriately
-        @test_invoker_helper.process_deep_dependencies( core ) do |dependencies_list|
-          @dependinator.load_test_object_deep_dependencies( dependencies_list )
-        end
-        # tell rake to create test runner if needed
-        @task_invoker.invoke_test_runner( runner )
-        # enhance object file dependencies to capture externalities influencing regeneration
-        @dependinator.enhance_test_build_object_dependencies( objects )
-        # associate object files with executable
-        @dependinator.setup_test_executable_dependencies( test, objects )
-        # 3, 2, 1... launch
-        @task_invoker.invoke_test_results( results_pass )
-      rescue => e
-        @build_invoker_utils.process_exception( e, context )
-      ensure
-        @plugin_manager.post_test
-      end
-      # store away what's been processed
-      @mocks.concat( mock_list )
-      @sources.concat( sources )
-    end
-    # post-process collected mock list
-    @mocks.uniq!
-    # post-process collected sources list
-    @sources.uniq!
-  end
-  def refresh_deep_dependencies
-    @file_wrapper.rm_f(
-      @file_wrapper.directory_listing(
-        File.join( @configurator.project_test_dependencies_path, '*' + @configurator.extension_dependencies ) ) )
-    @test_invoker_helper.process_deep_dependencies(
-      @configurator.collection_all_tests + @configurator.collection_all_source )
-  end
-end

data/new_project_template/vendor/ceedling/lib/test_invoker_helper.rb DELETED Viewed

@@ -1,28 +0,0 @@
-class TestInvokerHelper
-  constructor :configurator, :task_invoker, :test_includes_extractor, :file_finder, :file_path_utils, :file_wrapper
-  def clean_results(results, options)
-    @file_wrapper.rm_f( results[:fail] )
-    @file_wrapper.rm_f( results[:pass] ) if (options[:force_run])
-  end
-  def process_deep_dependencies(files)
-    return if (not @configurator.project_use_deep_dependencies)
-    dependencies_list = @file_path_utils.form_test_dependencies_filelist( files )
-    @task_invoker.invoke_test_dependencies_files( dependencies_list )
-    yield( dependencies_list ) if block_given?
-  end
-  def extract_sources(test)
-    sources  = []
-    includes = @test_includes_extractor.lookup_includes_list(test)
-    includes.each { |include| sources << @file_finder.find_compilation_input_file(include, :ignore) }
-    return sources.compact
-  end
-end

data/new_project_template/vendor/ceedling/lib/tool_executor.rb DELETED Viewed

@@ -1,212 +0,0 @@
-require 'constants'
-class ShellExecutionException < RuntimeError
-  attr_reader :shell_result
-  def initialize(shell_result)
-    @shell_result = shell_result
-  end
-end
-class ToolExecutor
-  constructor :configurator, :tool_executor_helper, :streaminator, :system_wrapper
-  def setup
-    @tool_name  = ''
-    @executable = ''
-  end
-  # build up a command line from yaml provided config
-  def build_command_line(tool_config, *args)
-    @tool_name  = tool_config[:name]
-    @executable = tool_config[:executable]
-    command = {}
-    # basic premise is to iterate top to bottom through arguments using '$' as
-    #  a string replacement indicator to expand globals or inline yaml arrays
-    #  into command line arguments via substitution strings
-    command[:line] = [
-      @tool_executor_helper.osify_path_separators( expandify_element(@executable, *args) ),
-      build_arguments(tool_config[:arguments], *args),
-      ].join(' ').strip
-    command[:options] = {
-      :stderr_redirect => @tool_executor_helper.stderr_redirection(tool_config, @configurator.project_logging),
-      :background_exec => tool_config[:background_exec]
-      }
-    return command
-  end
-  # shell out, execute command, and return response
-  def exec(command, options={}, args=[])
-    options[:boom] = true if (options[:boom].nil?)
-    options[:stderr_redirect] = StdErrRedirect::NONE if (options[:stderr_redirect].nil?)
-    options[:background_exec] = BackgroundExec::NONE if (options[:background_exec].nil?)
-    # build command line
-    command_line = [
-      @tool_executor_helper.background_exec_cmdline_prepend( options ),
-      command.strip,
-      args,
-      @tool_executor_helper.stderr_redirect_cmdline_append( options ),
-      @tool_executor_helper.background_exec_cmdline_append( options ),
-      ].flatten.compact.join(' ')
-    shell_result = {}
-    # depending on background exec option, we shell out differently
-    if (options[:background_exec] != BackgroundExec::NONE)
-      shell_result = @system_wrapper.shell_system( command_line )
-    else
-      shell_result = @system_wrapper.shell_backticks( command_line )
-    end
-    @tool_executor_helper.print_happy_results( command_line, shell_result, options[:boom] )
-    @tool_executor_helper.print_error_results( command_line, shell_result, options[:boom] )
-    # go boom if exit code isn't 0 (but in some cases we don't want a non-0 exit code to raise)
-    raise ShellExecutionException.new(shell_result) if ((shell_result[:exit_code] != 0) and options[:boom])
-    return shell_result
-  end
-  private #############################
-  def build_arguments(config, *args)
-    build_string = ''
-    return nil if (config.nil?)
-    # iterate through each argument
-    # the yaml blob array needs to be flattened so that yaml substitution
-    # is handled correctly, since it creates a nested array when an anchor is
-    # dereferenced
-    config.flatten.each do |element|
-      argument = ''
-      case(element)
-        # if we find a simple string then look for string replacement operators
-        #  and expand with the parameters in this method's argument list
-        when String then argument = expandify_element(element, *args)
-        # if we find a hash, then we grab the key as a substitution string and expand the
-        #  hash's value(s) within that substitution string
-        when Hash   then argument = dehashify_argument_elements(element)
-      end
-      build_string.concat("#{argument} ") if (argument.length > 0)
-    end
-    build_string.strip!
-    return build_string if (build_string.length > 0)
-    return nil
-  end
-  # handle simple text string argument & argument array string replacement operators
-  def expandify_element(element, *args)
-    match = //
-    to_process = nil
-    args_index = 0
-    # handle ${#} input replacement
-    if (element =~ TOOL_EXECUTOR_ARGUMENT_REPLACEMENT_PATTERN)
-      args_index = ($2.to_i - 1)
-      if (args.nil? or args[args_index].nil?)
-        @streaminator.stderr_puts("ERROR: Tool '#{@tool_name}' expected valid argument data to accompany replacement operator #{$1}.", Verbosity::ERRORS)
-        raise
-      end
-      match = /#{Regexp.escape($1)}/
-      to_process = args[args_index]
-    end
-    # simple string argument: replace escaped '\$' and strip
-    element.sub!(/\\\$/, '$')
-    element.strip!
-    # handle inline ruby execution
-    if (element =~ RUBY_EVAL_REPLACEMENT_PATTERN)
-      element.replace(eval($1))
-    end
-    build_string = ''
-    # handle array or anything else passed into method to be expanded in place of replacement operators
-    case (to_process)
-      when Array then to_process.each {|value| build_string.concat( "#{element.sub(match, value.to_s)} " ) } if (to_process.size > 0)
-      else build_string.concat( element.sub(match, to_process.to_s) )
-    end
-    # handle inline ruby string substitution
-    if (build_string =~ RUBY_STRING_REPLACEMENT_PATTERN)
-      build_string.replace(@system_wrapper.module_eval(build_string))
-    end
-    return build_string.strip
-  end
-  # handle argument hash: keys are substitution strings, values are data to be expanded within substitution strings
-  def dehashify_argument_elements(hash)
-    build_string = ''
-    elements = []
-    # grab the substitution string (hash key)
-    substitution = hash.keys[0].to_s
-    # grab the string(s) to squirt into the substitution string (hash value)
-    expand = hash[hash.keys[0]]
-    if (expand.nil?)
-      @streaminator.stderr_puts("ERROR: Tool '#{@tool_name}' could not expand nil elements for substitution string '#{substitution}'.", Verbosity::ERRORS)
-      raise
-    end
-    # array-ify expansion input if only a single string
-    expansion = ((expand.class == String) ? [expand] : expand)
-    expansion.each do |item|
-      # code eval substitution
-      if (item =~ RUBY_EVAL_REPLACEMENT_PATTERN)
-        elements << eval($1)
-      # string eval substitution
-      elsif (item =~ RUBY_STRING_REPLACEMENT_PATTERN)
-        elements << @system_wrapper.module_eval(item)
-      # global constants
-      elsif (@system_wrapper.constants_include?(item))
-        const = Object.const_get(item)
-        if (const.nil?)
-          @streaminator.stderr_puts("ERROR: Tool '#{@tool_name}' found constant '#{item}' to be nil.", Verbosity::ERRORS)
-          raise
-        else
-          elements << const
-        end
-      elsif (item.class == Array)
-        elements << item
-      elsif (item.class == String)
-        @streaminator.stderr_puts("ERROR: Tool '#{@tool_name}' cannot expand nonexistent value '#{item}' for substitution string '#{substitution}'.", Verbosity::ERRORS)
-        raise
-      else
-        @streaminator.stderr_puts("ERROR: Tool '#{@tool_name}' cannot expand value having type '#{item.class}' for substitution string '#{substitution}'.", Verbosity::ERRORS)
-        raise
-      end
-    end
-    # expand elements (whether string or array) into substitution string & replace escaped '\$'
-    elements.flatten!
-    elements.each do |element|
-      build_string.concat( substitution.sub(/([^\\]*)\$/, "\\1#{element}") ) # don't replace escaped '\$' but allow us to replace just a lonesome '$'
-      build_string.gsub!(/\\\$/, '$')
-      build_string.concat(' ')
-    end
-    return build_string.strip
-  end
-end

data/new_project_template/vendor/ceedling/lib/tool_executor_helper.rb DELETED Viewed

@@ -1,115 +0,0 @@
-require 'constants' # for Verbosity enumeration & $stderr redirect enumeration
-class ToolExecutorHelper
-  constructor :streaminator, :system_utils, :system_wrapper
-  def stderr_redirection(tool_config, logging)
-    # if there's no logging enabled, return :stderr_redirect unmodified
-    return tool_config[:stderr_redirect] if (not logging)
-    # if there is logging enabled but the redirect is a custom value (not enum), return the custom string
-    return tool_config[:stderr_redirect] if (tool_config[:stderr_redirect].class == String)
-    # if logging is enabled but there's no custom string, return the AUTO enumeration so $stderr goes into the log
-    return StdErrRedirect::AUTO
-  end
-  def background_exec_cmdline_prepend(tool_config)
-    return nil if (tool_config[:background_exec].nil?)
-    config_exec = tool_config[:background_exec]
-    if ((config_exec == BackgroundExec::AUTO) and (@system_wrapper.windows?))
-      return 'start'
-    end
-    if (config_exec == BackgroundExec::WIN)
-      return 'start'
-    end
-    return nil
-  end
-  def osify_path_separators(executable)
-    return executable.gsub(/\//, '\\') if (@system_wrapper.windows?)
-    return executable
-  end
-  def stderr_redirect_cmdline_append(tool_config)
-    return nil if (tool_config[:stderr_redirect].nil?)
-    config_redirect = tool_config[:stderr_redirect]
-    redirect        = StdErrRedirect::NONE
-    if (config_redirect == StdErrRedirect::AUTO)
-       if (@system_wrapper.windows?)
-         redirect = StdErrRedirect::WIN
-       else
-         if (@system_utils.tcsh_shell?)
-           redirect = StdErrRedirect::TCSH
-         else
-           redirect = StdErrRedirect::UNIX
-         end
-       end
-    end
-    case redirect
-      # we may need more complicated processing after some learning with various environments
-      when StdErrRedirect::NONE then nil
-      when StdErrRedirect::WIN  then '2>&1'
-      when StdErrRedirect::UNIX then '2>&1'
-      when StdErrRedirect::TCSH then '|&'
-      else redirect.to_s
-    end
-  end
-  def background_exec_cmdline_append(tool_config)
-    return nil if (tool_config[:background_exec].nil?)
-    config_exec = tool_config[:background_exec]
-    # if :auto & windows, then we already prepended 'start' and should append nothing
-    return nil if ((config_exec == BackgroundExec::AUTO) and (@system_wrapper.windows?))
-    # if :auto & not windows, then we append standard '&'
-    return '&' if ((config_exec == BackgroundExec::AUTO) and (not @system_wrapper.windows?))
-    # if explicitly Unix, then append '&'
-    return '&' if (config_exec == BackgroundExec::UNIX)
-    # all other cases, including :none, :win, & anything unrecognized, append nothing
-    return nil
-  end
-  # if command succeeded and we have verbosity cranked up, spill our guts
-  def print_happy_results(command_str, shell_result, boom=true)
-    if ((shell_result[:exit_code] == 0) or ((shell_result[:exit_code] != 0) and not boom))
-      output  = "> Shell executed command:\n"
-      output += "#{command_str}\n"
-      output += "> Produced output:\n"             if (not shell_result[:output].empty?)
-      output += "#{shell_result[:output].strip}\n" if (not shell_result[:output].empty?)
-      output += "> And exited with status: [#{shell_result[:exit_code]}].\n" if (shell_result[:exit_code] != 0)
-      output += "\n"
-      @streaminator.stdout_puts(output, Verbosity::OBNOXIOUS)
-    end
-  end
-  # if command failed and we have verbosity set to minimum error level, spill our guts
-  def print_error_results(command_str, shell_result, boom=true)
-    if ((shell_result[:exit_code] != 0) and boom)
-      output  = "ERROR: Shell command failed.\n"
-      output += "> Shell executed command:\n"
-      output += "'#{command_str}'\n"
-      output += "> Produced output:\n"             if (not shell_result[:output].empty?)
-      output += "#{shell_result[:output].strip}\n" if (not shell_result[:output].empty?)
-      output += "> And exited with status: [#{shell_result[:exit_code]}].\n" if (shell_result[:exit_code] != nil)
-      output += "> And then likely crashed.\n"                               if (shell_result[:exit_code] == nil)
-      output += "\n"
-      @streaminator.stderr_puts(output, Verbosity::ERRORS)
-    end
-  end
-end

data/new_project_template/vendor/ceedling/lib/verbosinator.rb DELETED Viewed

@@ -1,10 +0,0 @@
-class Verbosinator
-  constructor :configurator
-  def should_output?(level)
-    return (level <= @configurator.project_verbosity)
-  end
-end

data/new_project_template/vendor/ceedling/lib/yaml_wrapper.rb DELETED Viewed

@@ -1,16 +0,0 @@
-require 'yaml'
-class YamlWrapper
-  def load(filepath)
-    return YAML.load(File.read(filepath))
-  end
-  def dump(filepath, structure)
-    File.open(filepath, 'w') do |output|
-      YAML.dump(structure, output)
-    end
-  end
-end