ceedling 0.13.0 → 0.15.0

data/lib/{file_system_utils.rb → ceedling/file_system_utils.rb}

@@ -1,69 +1,69 @@
-require 'rubygems'
-require 'rake'
-require 'set'
-require 'fileutils'
-require 'file_path_utils.rb'
-
-
-class FileSystemUtils
-  
-  constructor :file_wrapper
-
-  # build up path list from input of one or more strings or arrays of (+/-) paths & globs
-  def collect_paths(*paths)
-    raw   = []  # all paths and globs
-    plus  = Set.new # all paths to expand and add
-    minus = Set.new # all paths to remove from plus set
-    
-    # assemble all globs and simple paths, reforming our glob notation to ruby globs
-    paths.each do |paths_container|
-      case (paths_container)
-        when String then raw << (FilePathUtils::reform_glob(paths_container))
-        when Array  then paths_container.each {|path| raw << (FilePathUtils::reform_glob(path))}
-        else raise "Don't know how to handle #{paths_container.class}"
-      end
-    end
-
-    # iterate through each path and glob
-    raw.each do |path|
-    
-      dirs = []  # container for only (expanded) paths
-    
-      # if a glob, expand it and slurp up all non-file paths
-      if path.include?('*')
-        # grab base directory only if globs are snug up to final path separator
-        if (path =~ /\/\*+$/)
-          dirs << FilePathUtils.extract_path(path)
-        end
-        
-        # grab expanded sub-directory globs
-        expanded = @file_wrapper.directory_listing( FilePathUtils.extract_path_no_aggregation_operators(path) )
-        expanded.each do |entry|
-          dirs << entry if @file_wrapper.directory?(entry)
-        end
-        
-      # else just grab simple path
-      # note: we could just run this through glob expansion but such an
-      #       approach doesn't handle a path not yet on disk)
-      else
-        dirs << FilePathUtils.extract_path_no_aggregation_operators(path)
-      end
-      
-      # add dirs to the appropriate set based on path aggregation modifier if present
-      FilePathUtils.add_path?(path) ? plus.merge(dirs) : minus.merge(dirs)
-    end
-
-    return (plus - minus).to_a.uniq
-  end
-
-
-  # given a file list, add to it or remove from it
-  def revise_file_list(list, revisions)
-    revisions.each do |revision|
-      # include or exclude file or glob to file list
-      file = FilePathUtils.extract_path_no_aggregation_operators( revision )
-      FilePathUtils.add_path?(revision) ? list.include(file) : list.exclude(file)
-    end
-  end
-
-end
+require 'rubygems'
+require 'rake'
+require 'set'
+require 'fileutils'
+require 'ceedling/file_path_utils'
+
+
+class FileSystemUtils
+  
+  constructor :file_wrapper
+
+  # build up path list from input of one or more strings or arrays of (+/-) paths & globs
+  def collect_paths(*paths)
+    raw   = []  # all paths and globs
+    plus  = Set.new # all paths to expand and add
+    minus = Set.new # all paths to remove from plus set
+    
+    # assemble all globs and simple paths, reforming our glob notation to ruby globs
+    paths.each do |paths_container|
+      case (paths_container)
+        when String then raw << (FilePathUtils::reform_glob(paths_container))
+        when Array  then paths_container.each {|path| raw << (FilePathUtils::reform_glob(path))}
+        else raise "Don't know how to handle #{paths_container.class}"
+      end
+    end
+
+    # iterate through each path and glob
+    raw.each do |path|
+    
+      dirs = []  # container for only (expanded) paths
+    
+      # if a glob, expand it and slurp up all non-file paths
+      if path.include?('*')
+        # grab base directory only if globs are snug up to final path separator
+        if (path =~ /\/\*+$/)
+          dirs << FilePathUtils.extract_path(path)
+        end
+        
+        # grab expanded sub-directory globs
+        expanded = @file_wrapper.directory_listing( FilePathUtils.extract_path_no_aggregation_operators(path) )
+        expanded.each do |entry|
+          dirs << entry if @file_wrapper.directory?(entry)
+        end
+        
+      # else just grab simple path
+      # note: we could just run this through glob expansion but such an
+      #       approach doesn't handle a path not yet on disk)
+      else
+        dirs << FilePathUtils.extract_path_no_aggregation_operators(path)
+      end
+      
+      # add dirs to the appropriate set based on path aggregation modifier if present
+      FilePathUtils.add_path?(path) ? plus.merge(dirs) : minus.merge(dirs)
+    end
+
+    return (plus - minus).to_a.uniq
+  end
+
+
+  # given a file list, add to it or remove from it
+  def revise_file_list(list, revisions)
+    revisions.each do |revision|
+      # include or exclude file or glob to file list
+      file = FilePathUtils.extract_path_no_aggregation_operators( revision )
+      FilePathUtils.add_path?(revision) ? list.include(file) : list.exclude(file)
+    end
+  end
+
+end

data/lib/{file_system_wrapper.rb → ceedling/file_system_wrapper.rb}

@@ -1,10 +1,10 @@
-
-class FileSystemWrapper
-
-  def cd(path)
-    FileUtils.cd path do
-      yield
-    end
-  end
-
+
+class FileSystemWrapper
+
+  def cd(path)
+    FileUtils.cd path do
+      yield
+    end
+  end
+
 end

data/lib/{file_wrapper.rb → ceedling/file_wrapper.rb}

@@ -1,79 +1,79 @@
-require 'rubygems'
-require 'rake' # for FileList
-require 'constants'
-require 'fileutils'
-
-
-class FileWrapper
-
-  def get_expanded_path(path)
-    return File.expand_path(path)
-  end
-
-  def basename(path, extension=nil)
-    return File.basename(path, extension) if extension
-    return File.basename(path)
-  end
-
-  def exist?(filepath)
-    return true if (filepath == NULL_FILE_PATH)
-    return File.exist?(filepath)
-  end
-
-  def directory?(path)
-    return File.directory?(path)
-  end
-
-  def dirname(path)
-    return File.dirname(path)
-  end
-
-  def directory_listing(glob)
-    return Dir.glob(glob)
-  end
-
-  def rm_f(filepath, options={})
-    FileUtils.rm_f(filepath, options)
-  end
-
-  def rm_r(filepath, options={})
-    FileUtils.rm_r(filepath, options={})
-  end
-  
-  def cp(source, destination, options={})
-    FileUtils.cp(source, destination, options)
-  end
-
-  def compare(from, to)
-    return FileUtils.compare_file(from, to)
-  end
-  
-  def open(filepath, flags)
-    File.open(filepath, flags) do |file|
-      yield(file)
-    end
-  end
-
-  def read(filepath)
-    return File.read(filepath)
-  end
-
-  def touch(filepath, options={})
-    FileUtils.touch(filepath, options)
-  end
-
-  def write(filepath, contents, flags='w')
-    File.open(filepath, flags) do |file|
-      file.write(contents)
-    end    
-  end
-
-  def readlines(filepath)
-    return File.readlines(filepath)
-  end
-
-  def instantiate_file_list(files=[])
-    return FileList.new(files)
-  end
-
-end
+require 'rubygems'
+require 'rake' # for FileList
+require 'fileutils'
+require 'ceedling/constants'
+
+
+class FileWrapper
+
+  def get_expanded_path(path)
+    return File.expand_path(path)
+  end
+
+  def basename(path, extension=nil)
+    return File.basename(path, extension) if extension
+    return File.basename(path)
+  end
+
+  def exist?(filepath)
+    return true if (filepath == NULL_FILE_PATH)
+    return File.exist?(filepath)
+  end
+
+  def directory?(path)
+    return File.directory?(path)
+  end
+
+  def dirname(path)
+    return File.dirname(path)
+  end
+
+  def directory_listing(glob)
+    return Dir.glob(glob)
+  end
+
+  def rm_f(filepath, options={})
+    FileUtils.rm_f(filepath, options)
+  end
+
+  def rm_r(filepath, options={})
+    FileUtils.rm_r(filepath, options={})
+  end
+  
+  def cp(source, destination, options={})
+    FileUtils.cp(source, destination, options)
+  end
+
+  def compare(from, to)
+    return FileUtils.compare_file(from, to)
+  end
+  
+  def open(filepath, flags)
+    File.open(filepath, flags) do |file|
+      yield(file)
+    end
+  end
+
+  def read(filepath)
+    return File.read(filepath)
+  end
+
+  def touch(filepath, options={})
+    FileUtils.touch(filepath, options)
+  end
+
+  def write(filepath, contents, flags='w')
+    File.open(filepath, flags) do |file|
+      file.write(contents)
+    end    
+  end
+
+  def readlines(filepath)
+    return File.readlines(filepath)
+  end
+
+  def instantiate_file_list(files=[])
+    return FileList.new(files)
+  end
+
+end

data/lib/{flaginator.rb → ceedling/flaginator.rb}

@@ -1,54 +1,54 @@
-require 'rubygems'
-require 'rake' # for ext()
-require 'fileutils'
-require 'constants'
-
-
-# :flags:
-#   :release:
-#     :compile:
-#       :*:          # add '-foo' to compilation of all files not main.c
-#         - -foo
-#       :main:       # add '-Wall' to compilation of main.c
-#         - -Wall
-#   :test:
-#     :link:
-#       :test_main:  # add '--bar --baz' to linking of test_main.exe
-#         - --bar
-#         - --baz
-
-
-class Flaginator
-
-  constructor :configurator
-
-  def flag_down( operation, context, file )
-    # create configurator accessor method
-    accessor = ('flags_' + context.to_s).to_sym
-    
-    # create simple filename key from whatever filename provided
-    file_key = File.basename( file ).ext('').to_sym
-    
-    # if no entry in configuration for flags for this context, bail out
-    return [] if not @configurator.respond_to?( accessor )
-    
-    # get flags sub hash associated with this context
-    flags = @configurator.send( accessor )
-
-    # if operation not represented in flags hash, bail out
-    return [] if not flags.include?( operation )
-    
-    # redefine flags to sub hash associated with the operation
-    flags = flags[operation]
-    
-    # if our file is in the flags hash, extract the array of flags
-    if (flags.include?( file_key )) then return flags[file_key]
-    # if our file isn't in the flags hash, but there is default for all other files, extract array of flags
-    elsif (flags.include?( :* )) then return flags[:*]
-    end
-
-    # fall through: flags were specified but none applying to present file
-    return []
-  end
-
-end
+require 'rubygems'
+require 'rake' # for ext()
+require 'fileutils'
+require 'ceedling/constants'
+
+
+# :flags:
+#   :release:
+#     :compile:
+#       :*:          # add '-foo' to compilation of all files not main.c
+#         - -foo
+#       :main:       # add '-Wall' to compilation of main.c
+#         - -Wall
+#   :test:
+#     :link:
+#       :test_main:  # add '--bar --baz' to linking of test_main.exe
+#         - --bar
+#         - --baz
+
+
+class Flaginator
+
+  constructor :configurator
+
+  def flag_down( operation, context, file )
+    # create configurator accessor method
+    accessor = ('flags_' + context.to_s).to_sym
+    
+    # create simple filename key from whatever filename provided
+    file_key = File.basename( file ).ext('').to_sym
+    
+    # if no entry in configuration for flags for this context, bail out
+    return [] if not @configurator.respond_to?( accessor )
+    
+    # get flags sub hash associated with this context
+    flags = @configurator.send( accessor )
+
+    # if operation not represented in flags hash, bail out
+    return [] if not flags.include?( operation )
+    
+    # redefine flags to sub hash associated with the operation
+    flags = flags[operation]
+    
+    # if our file is in the flags hash, extract the array of flags
+    if (flags.include?( file_key )) then return flags[file_key]
+    # if our file isn't in the flags hash, but there is default for all other files, extract array of flags
+    elsif (flags.include?( :* )) then return flags[:*]
+    end
+
+    # fall through: flags were specified but none applying to present file
+    return []
+  end
+
+end

data/lib/{generator.rb → ceedling/generator.rb}

@@ -1,164 +1,164 @@
-require 'constants'
-
-
-class Generator
-
-  constructor :configurator,
-              :generator_helper,
-              :preprocessinator,
-              :cmock_builder,
-              :generator_test_runner,
-              :generator_test_results,
-              :flaginator,
-              :test_includes_extractor,
-              :tool_executor,
-              :file_finder,
-              :file_path_utils,
-              :streaminator,
-              :plugin_manager,
-              :file_wrapper
-
-
-  def generate_shallow_includes_list(context, file)
-    @preprocessinator.preprocess_shallow_includes(file)
-  end
-
-  def generate_preprocessed_file(context, file)
-    @streaminator.stdout_puts("Preprocessing #{File.basename(file)}...", Verbosity::NORMAL)
-    @preprocessinator.preprocess_file(file)
-  end
-
-  def generate_dependencies_file(tool, context, source, object, dependencies)
-    @streaminator.stdout_puts("Generating dependencies for #{File.basename(source)}...", Verbosity::NORMAL)
-    
-    command = 
-      @tool_executor.build_command_line(
-        tool,
-        source,
-        dependencies,
-        object)
-    
-    @tool_executor.exec( command[:line], command[:options] )
-  end
-
-  def generate_mock(context, header_filepath)
-    arg_hash = {:header_file => header_filepath, :context => context}
-    @plugin_manager.pre_mock_generate( arg_hash )
-    
-    begin
-      @cmock_builder.cmock.setup_mocks( arg_hash[:header_file] )
-    rescue
-      raise
-    ensure
-      @plugin_manager.post_mock_generate( arg_hash )
-    end
-  end
-
-  # test_filepath may be either preprocessed test file or original test file
-  def generate_test_runner(context, test_filepath, runner_filepath)
-    arg_hash = {:context => context, :test_file => test_filepath, :runner_file => runner_filepath}
-    @plugin_manager.pre_runner_generate(arg_hash)
-    
-    # collect info we need
-    module_name = File.basename(arg_hash[:test_file])
-    test_cases  = @generator_test_runner.find_test_cases( @file_finder.find_test_from_runner_path(runner_filepath) )
-    mock_list   = @test_includes_extractor.lookup_raw_mock_list(arg_hash[:test_file])
-
-    @streaminator.stdout_puts("Generating runner for #{module_name}...", Verbosity::NORMAL)
-    
-    # build runner file
-    begin
-      @generator_test_runner.generate(module_name, runner_filepath, test_cases, mock_list)
-    rescue
-      raise
-    ensure
-      @plugin_manager.post_runner_generate(arg_hash)    
-    end
-  end
-
-  def generate_object_file(tool, context, source, object, list='')    
-    shell_result = {}
-    arg_hash = {:tool => tool, :context => context, :source => source, :object => object, :list => list}
-    @plugin_manager.pre_compile_execute(arg_hash)
-
-    @streaminator.stdout_puts("Compiling #{File.basename(arg_hash[:source])}...", Verbosity::NORMAL)
-    command =
-      @tool_executor.build_command_line( arg_hash[:tool],
-                                         arg_hash[:source],
-                                         arg_hash[:object],
-                                         arg_hash[:list],
-                                         @flaginator.flag_down( OPERATION_COMPILE_SYM, context, source ) )
-
-    begin
-      shell_result = @tool_executor.exec( command[:line], command[:options] )
-    rescue ShellExecutionException => ex
-      shell_result = ex.shell_result
-      raise ''
-    ensure
-      arg_hash[:shell_result] = shell_result
-      @plugin_manager.post_compile_execute(arg_hash)
-    end
-  end
-
-  def generate_executable_file(tool, context, objects, executable, map='')
-    shell_result = {}
-    arg_hash = {:tool => tool, :context => context, :objects => objects, :executable => executable, :map => map}
-    @plugin_manager.pre_link_execute(arg_hash)
-    
-    @streaminator.stdout_puts("Linking #{File.basename(arg_hash[:executable])}...", Verbosity::NORMAL)
-    command =
-      @tool_executor.build_command_line( arg_hash[:tool],
-                                         arg_hash[:objects],
-                                         arg_hash[:executable],
-                                         arg_hash[:map],
-                                         @flaginator.flag_down( OPERATION_LINK_SYM, context, executable ) )
-    
-    begin
-      shell_result = @tool_executor.exec( command[:line], command[:options] )
-    rescue ShellExecutionException => ex
-      notice =    "\n" +
-                  "NOTICE: If the linker reports missing symbols, the following may be to blame:\n" +
-                  "  1. Test lacks #include statements corresponding to needed source files.\n" +
-                  "  2. Project search paths do not contain source files corresponding to #include statements in the test.\n"
-      
-      if (@configurator.project_use_mocks)
-        notice += "  3. Test does not #include needed mocks.\n\n"
-      else
-        notice += "\n"
-      end
-      
-      @streaminator.stderr_puts(notice, Verbosity::COMPLAIN)
-      shell_result = ex.shell_result
-      raise ''
-    ensure
-      arg_hash[:shell_result] = shell_result
-      @plugin_manager.post_link_execute(arg_hash)
-    end
-  end
-
-  def generate_test_results(tool, context, executable, result)
-    arg_hash = {:tool => tool, :context => context, :executable => executable, :result_file => result}
-    @plugin_manager.pre_test_fixture_execute(arg_hash)
-    
-    @streaminator.stdout_puts("Running #{File.basename(arg_hash[:executable])}...", Verbosity::NORMAL)
-    
-    # Unity's exit code is equivalent to the number of failed tests, so we tell @tool_executor not to fail out if there are failures
-    # so that we can run all tests and collect all results
-    command = @tool_executor.build_command_line(arg_hash[:tool], arg_hash[:executable])
-    command[:options][:boom] = false
-    shell_result = @tool_executor.exec( command[:line], command[:options] )
-    
-    @generator_helper.test_results_error_handler(executable, shell_result)
-    
-    processed = @generator_test_results.process_and_write_results( shell_result,
-                                                                   arg_hash[:result_file],
-                                                                   @file_finder.find_test_from_file_path(arg_hash[:executable]) )
-    
-    arg_hash[:result_file]  = processed[:result_file]
-    arg_hash[:results]      = processed[:results]
-    arg_hash[:shell_result] = shell_result # for raw output display if no plugins for formatted display
-    
-    @plugin_manager.post_test_fixture_execute(arg_hash)
-  end
-  
-end
+require 'ceedling/constants'
+
+
+class Generator
+
+  constructor :configurator,
+              :generator_helper,
+              :preprocessinator,
+              :cmock_builder,
+              :generator_test_runner,
+              :generator_test_results,
+              :flaginator,
+              :test_includes_extractor,
+              :tool_executor,
+              :file_finder,
+              :file_path_utils,
+              :streaminator,
+              :plugin_manager,
+              :file_wrapper
+
+
+  def generate_shallow_includes_list(context, file)
+    @preprocessinator.preprocess_shallow_includes(file)
+  end
+
+  def generate_preprocessed_file(context, file)
+    @streaminator.stdout_puts("Preprocessing #{File.basename(file)}...", Verbosity::NORMAL)
+    @preprocessinator.preprocess_file(file)
+  end
+
+  def generate_dependencies_file(tool, context, source, object, dependencies)
+    @streaminator.stdout_puts("Generating dependencies for #{File.basename(source)}...", Verbosity::NORMAL)
+    
+    command = 
+      @tool_executor.build_command_line(
+        tool,
+        source,
+        dependencies,
+        object)
+    
+    @tool_executor.exec( command[:line], command[:options] )
+  end
+
+  def generate_mock(context, header_filepath)
+    arg_hash = {:header_file => header_filepath, :context => context}
+    @plugin_manager.pre_mock_generate( arg_hash )
+    
+    begin
+      @cmock_builder.cmock.setup_mocks( arg_hash[:header_file] )
+    rescue
+      raise
+    ensure
+      @plugin_manager.post_mock_generate( arg_hash )
+    end
+  end
+
+  # test_filepath may be either preprocessed test file or original test file
+  def generate_test_runner(context, test_filepath, runner_filepath)
+    arg_hash = {:context => context, :test_file => test_filepath, :runner_file => runner_filepath}
+    @plugin_manager.pre_runner_generate(arg_hash)
+    
+    # collect info we need
+    module_name = File.basename(arg_hash[:test_file])
+    test_cases  = @generator_test_runner.find_test_cases( @file_finder.find_test_from_runner_path(runner_filepath) )
+    mock_list   = @test_includes_extractor.lookup_raw_mock_list(arg_hash[:test_file])
+
+    @streaminator.stdout_puts("Generating runner for #{module_name}...", Verbosity::NORMAL)
+    
+    # build runner file
+    begin
+      @generator_test_runner.generate(module_name, runner_filepath, test_cases, mock_list)
+    rescue
+      raise
+    ensure
+      @plugin_manager.post_runner_generate(arg_hash)    
+    end
+  end
+
+  def generate_object_file(tool, context, source, object, list='')    
+    shell_result = {}
+    arg_hash = {:tool => tool, :context => context, :source => source, :object => object, :list => list}
+    @plugin_manager.pre_compile_execute(arg_hash)
+
+    @streaminator.stdout_puts("Compiling #{File.basename(arg_hash[:source])}...", Verbosity::NORMAL)
+    command =
+      @tool_executor.build_command_line( arg_hash[:tool],
+                                         arg_hash[:source],
+                                         arg_hash[:object],
+                                         arg_hash[:list],
+                                         @flaginator.flag_down( OPERATION_COMPILE_SYM, context, source ) )
+
+    begin
+      shell_result = @tool_executor.exec( command[:line], command[:options] )
+    rescue ShellExecutionException => ex
+      shell_result = ex.shell_result
+      raise ''
+    ensure
+      arg_hash[:shell_result] = shell_result
+      @plugin_manager.post_compile_execute(arg_hash)
+    end
+  end
+
+  def generate_executable_file(tool, context, objects, executable, map='')
+    shell_result = {}
+    arg_hash = {:tool => tool, :context => context, :objects => objects, :executable => executable, :map => map}
+    @plugin_manager.pre_link_execute(arg_hash)
+    
+    @streaminator.stdout_puts("Linking #{File.basename(arg_hash[:executable])}...", Verbosity::NORMAL)
+    command =
+      @tool_executor.build_command_line( arg_hash[:tool],
+                                         arg_hash[:objects],
+                                         arg_hash[:executable],
+                                         arg_hash[:map],
+                                         @flaginator.flag_down( OPERATION_LINK_SYM, context, executable ) )
+    
+    begin
+      shell_result = @tool_executor.exec( command[:line], command[:options] )
+    rescue ShellExecutionException => ex
+      notice =    "\n" +
+                  "NOTICE: If the linker reports missing symbols, the following may be to blame:\n" +
+                  "  1. Test lacks #include statements corresponding to needed source files.\n" +
+                  "  2. Project search paths do not contain source files corresponding to #include statements in the test.\n"
+      
+      if (@configurator.project_use_mocks)
+        notice += "  3. Test does not #include needed mocks.\n\n"
+      else
+        notice += "\n"
+      end
+      
+      @streaminator.stderr_puts(notice, Verbosity::COMPLAIN)
+      shell_result = ex.shell_result
+      raise ''
+    ensure
+      arg_hash[:shell_result] = shell_result
+      @plugin_manager.post_link_execute(arg_hash)
+    end
+  end
+
+  def generate_test_results(tool, context, executable, result)
+    arg_hash = {:tool => tool, :context => context, :executable => executable, :result_file => result}
+    @plugin_manager.pre_test_fixture_execute(arg_hash)
+    
+    @streaminator.stdout_puts("Running #{File.basename(arg_hash[:executable])}...", Verbosity::NORMAL)
+    
+    # Unity's exit code is equivalent to the number of failed tests, so we tell @tool_executor not to fail out if there are failures
+    # so that we can run all tests and collect all results
+    command = @tool_executor.build_command_line(arg_hash[:tool], arg_hash[:executable])
+    command[:options][:boom] = false
+    shell_result = @tool_executor.exec( command[:line], command[:options] )
+    
+    @generator_helper.test_results_error_handler(executable, shell_result)
+    
+    processed = @generator_test_results.process_and_write_results( shell_result,
+                                                                   arg_hash[:result_file],
+                                                                   @file_finder.find_test_from_file_path(arg_hash[:executable]) )
+    
+    arg_hash[:result_file]  = processed[:result_file]
+    arg_hash[:results]      = processed[:results]
+    arg_hash[:shell_result] = shell_result # for raw output display if no plugins for formatted display
+    
+    @plugin_manager.post_test_fixture_execute(arg_hash)
+  end
+  
+end