ceedling 0.13.0 → 0.15.0

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

@@ -1,31 +1,31 @@
-
-class Loginator
-
-  constructor :configurator, :project_file_loader, :project_config_manager, :file_wrapper, :system_wrapper
-
-
-  def setup_log_filepath
-    config_files = []
-    config_files << @project_file_loader.main_file
-    config_files << @project_file_loader.user_file
-    config_files.concat( @project_config_manager.options_files )
-    config_files.compact!
-    config_files.map! { |file| file.ext('') }
-    
-    log_name = config_files.join( '_' )
-
-    @project_log_filepath = File.join( @configurator.project_log_path, log_name.ext('.log') )
-  end
-
-
-  def log(string, heading=nil)
-    return if (not @configurator.project_logging)
-  
-    output  = "\n[#{@system_wrapper.time_now}]"
-    output += " :: #{heading}" if (not heading.nil?)
-    output += "\n#{string.strip}\n"
-
-    @file_wrapper.write(@project_log_filepath, output, 'a')
-  end
-  
-end
+
+class Loginator
+
+  constructor :configurator, :project_file_loader, :project_config_manager, :file_wrapper, :system_wrapper
+
+
+  def setup_log_filepath
+    config_files = []
+    config_files << @project_file_loader.main_file
+    config_files << @project_file_loader.user_file
+    config_files.concat( @project_config_manager.options_files )
+    config_files.compact!
+    config_files.map! { |file| file.ext('') }
+    
+    log_name = config_files.join( '_' )
+
+    @project_log_filepath = File.join( @configurator.project_log_path, log_name.ext('.log') )
+  end
+
+
+  def log(string, heading=nil)
+    return if (not @configurator.project_logging)
+  
+    output  = "\n[#{@system_wrapper.time_now}]"
+    output += " :: #{heading}" if (not heading.nil?)
+    output += "\n#{string.strip}\n"
+
+    @file_wrapper.write(@project_log_filepath, output, 'a')
+  end
+  
+end

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

@@ -1,80 +1,80 @@
-
-class String
-  # reformat a multiline string to have given number of whitespace columns;
-  # helpful for formatting heredocs
-  def left_margin(margin=0)
-    non_whitespace_column = 0
-    new_lines = []
-    
-    # find first line with non-whitespace and count left columns of whitespace
-    self.each_line do |line|
-      if (line =~ /^\s*\S/)
-        non_whitespace_column = $&.length - 1
-        break
-      end
-    end
-    
-    # iterate through each line, chopping off leftmost whitespace columns and add back the desired whitespace margin
-    self.each_line do |line|
-      columns = []
-      margin.times{columns << ' '}
-      # handle special case of line being narrower than width to be lopped off
-      if (non_whitespace_column < line.length)
-        new_lines << "#{columns.join}#{line[non_whitespace_column..-1]}"
-      else
-        new_lines << "\n"
-      end
-    end
-    
-    return new_lines.join
-  end
-end
-
-class Plugin
-  attr_reader :name, :environment
-  attr_accessor :plugin_objects
-
-  def initialize(system_objects, name)
-    @environment = []
-    @ceedling = system_objects
-    @name = name
-    self.setup
-  end
-
-  def setup; end
-
-  # mock generation
-  def pre_mock_generate(arg_hash); end
-  def post_mock_generate(arg_hash); end
-
-  # test runner generation
-  def pre_runner_generate(arg_hash); end
-  def post_runner_generate(arg_hash); end
-
-  # compilation (test or source)
-  def pre_compile_execute(arg_hash); end
-  def post_compile_execute(arg_hash); end
-
-  # linking (test or source)
-  def pre_link_execute(arg_hash); end
-  def post_link_execute(arg_hash); end
-
-  # test fixture execution
-  def pre_test_fixture_execute(arg_hash); end
-  def post_test_fixture_execute(arg_hash); end
-
-  # test task
-  def pre_test; end
-  def post_test; end
-
-  # release task
-  def pre_release; end
-  def post_release; end
-
-  # whole shebang (any use of Ceedling)
-  def pre_build; end
-  def post_build; end
-  
-  def summary; end
-
-end
+
+class String
+  # reformat a multiline string to have given number of whitespace columns;
+  # helpful for formatting heredocs
+  def left_margin(margin=0)
+    non_whitespace_column = 0
+    new_lines = []
+    
+    # find first line with non-whitespace and count left columns of whitespace
+    self.each_line do |line|
+      if (line =~ /^\s*\S/)
+        non_whitespace_column = $&.length - 1
+        break
+      end
+    end
+    
+    # iterate through each line, chopping off leftmost whitespace columns and add back the desired whitespace margin
+    self.each_line do |line|
+      columns = []
+      margin.times{columns << ' '}
+      # handle special case of line being narrower than width to be lopped off
+      if (non_whitespace_column < line.length)
+        new_lines << "#{columns.join}#{line[non_whitespace_column..-1]}"
+      else
+        new_lines << "\n"
+      end
+    end
+    
+    return new_lines.join
+  end
+end
+
+class Plugin
+  attr_reader :name, :environment
+  attr_accessor :plugin_objects
+
+  def initialize(system_objects, name)
+    @environment = []
+    @ceedling = system_objects
+    @name = name
+    self.setup
+  end
+
+  def setup; end
+
+  # mock generation
+  def pre_mock_generate(arg_hash); end
+  def post_mock_generate(arg_hash); end
+
+  # test runner generation
+  def pre_runner_generate(arg_hash); end
+  def post_runner_generate(arg_hash); end
+
+  # compilation (test or source)
+  def pre_compile_execute(arg_hash); end
+  def post_compile_execute(arg_hash); end
+
+  # linking (test or source)
+  def pre_link_execute(arg_hash); end
+  def post_link_execute(arg_hash); end
+
+  # test fixture execution
+  def pre_test_fixture_execute(arg_hash); end
+  def post_test_fixture_execute(arg_hash); end
+
+  # test task
+  def pre_test(test); end
+  def post_test(test); end
+
+  # release task
+  def pre_release; end
+  def post_release; end
+
+  # whole shebang (any use of Ceedling)
+  def pre_build; end
+  def post_build; end
+  
+  def summary; end
+
+end

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

@@ -1,53 +1,53 @@
-require 'plugin'
-
-class PluginBuilder
-
-  attr_accessor :plugin_objects
-
-  def construct_plugin(plugin_name, object_map_yaml, system_objects)
-    # @streaminator.stdout_puts("Constructing plugin #{plugin_name}...", Verbosity::OBNOXIOUS)
-    object_map = {}
-    @plugin_objects = {}
-    @system_objects = system_objects
-
-    if object_map_yaml
-      @object_map = YAML.load(object_map_yaml)
-      @object_map.each_key do |obj|
-        construct_object(obj)
-      end
-    else
-      raise "Invalid object map for plugin #{plugin_name}!"
-    end
-
-    return @plugin_objects
-  end
-
-  private
-  
-  def camelize(underscored_name)
-    return underscored_name.gsub(/(_|^)([a-z0-9])/) {$2.upcase}
-  end
-
-  def construct_object(obj)
-    if @plugin_objects[obj].nil?
-      if @object_map[obj] && @object_map[obj]['compose']
-        @object_map[obj]['compose'].each do |dep|
-          construct_object(dep)
-        end
-      end
-      build_object(obj)
-    end
-  end
-
-  def build_object(new_object)
-    if @plugin_objects[new_object.to_sym].nil?
-      # @streaminator.stdout_puts("Building plugin object #{new_object}", Verbosity::OBNOXIOUS)
-      require new_object
-      class_name = camelize(new_object)
-      new_instance = eval("#{class_name}.new(@system_objects, class_name.to_s)")
-      new_instance.plugin_objects = @plugin_objects
-      @plugin_objects[new_object.to_sym] = new_instance
-    end
-  end
-
+require 'ceedling/plugin'
+
+class PluginBuilder
+
+  attr_accessor :plugin_objects
+
+  def construct_plugin(plugin_name, object_map_yaml, system_objects)
+    # @streaminator.stdout_puts("Constructing plugin #{plugin_name}...", Verbosity::OBNOXIOUS)
+    object_map = {}
+    @plugin_objects = {}
+    @system_objects = system_objects
+
+    if object_map_yaml
+      @object_map = YAML.load(object_map_yaml)
+      @object_map.each_key do |obj|
+        construct_object(obj)
+      end
+    else
+      raise "Invalid object map for plugin #{plugin_name}!"
+    end
+
+    return @plugin_objects
+  end
+
+  private
+  
+  def camelize(underscored_name)
+    return underscored_name.gsub(/(_|^)([a-z0-9])/) {$2.upcase}
+  end
+
+  def construct_object(obj)
+    if @plugin_objects[obj].nil?
+      if @object_map[obj] && @object_map[obj]['compose']
+        @object_map[obj]['compose'].each do |dep|
+          construct_object(dep)
+        end
+      end
+      build_object(obj)
+    end
+  end
+
+  def build_object(new_object)
+    if @plugin_objects[new_object.to_sym].nil?
+      # @streaminator.stdout_puts("Building plugin object #{new_object}", Verbosity::OBNOXIOUS)
+      require new_object
+      class_name = camelize(new_object)
+      new_instance = eval("#{class_name}.new(@system_objects, class_name.to_s)")
+      new_instance.plugin_objects = @plugin_objects
+      @plugin_objects[new_object.to_sym] = new_instance
+    end
+  end
+
 end

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

@@ -1,107 +1,107 @@
-require 'constants'
-require 'set'
-
-class PluginManager
-
-  constructor :configurator, :plugin_manager_helper, :streaminator, :reportinator, :system_wrapper
-
-  def setup
-    @build_fail_registry = []
-    @plugin_objects = [] # so we can preserve order
-  end
-  
-  def load_plugin_scripts(script_plugins, system_objects)
-    environment = []
-    
-    script_plugins.each do |plugin|
-      # protect against instantiating object multiple times due to processing config multiple times (option files, etc)
-			next if (@plugin_manager_helper.include?(@plugin_objects, plugin))
-      begin
-        @system_wrapper.require_file( "#{plugin}.rb" )
-        object = @plugin_manager_helper.instantiate_plugin_script( camelize(plugin), system_objects, plugin )
-        @plugin_objects << object
-        environment += object.environment
-        
-        # add plugins to hash of all system objects
-        system_objects[plugin.downcase.to_sym] = object
-      rescue
-        puts "Exception raised while trying to load plugin: #{plugin}"
-        raise
-      end
-    end
-    
-    yield( { :environment => environment } ) if (environment.size > 0)
-  end
-  
-  def plugins_failed?
-    return (@build_fail_registry.size > 0)
-  end
-  
-  def print_plugin_failures
-    if (@build_fail_registry.size > 0)
-      report = @reportinator.generate_banner('BUILD FAILURE SUMMARY')
-      
-      @build_fail_registry.each do |failure|
-        report += "#{' - ' if (@build_fail_registry.size > 1)}#{failure}\n"
-      end
-      
-      report += "\n"
-      
-      @streaminator.stderr_puts(report, Verbosity::ERRORS)
-    end    
-  end
-  
-  def register_build_failure(message)
-    @build_fail_registry << message if (message and not message.empty?)
-  end
-
-  #### execute all plugin methods ####
-
-  def pre_mock_generate(arg_hash); execute_plugins(:pre_mock_generate, arg_hash); end
-  def post_mock_generate(arg_hash); execute_plugins(:post_mock_generate, arg_hash); end
-
-  def pre_runner_generate(arg_hash); execute_plugins(:pre_runner_generate, arg_hash); end
-  def post_runner_generate(arg_hash); execute_plugins(:post_runner_generate, arg_hash); end
-
-  def pre_compile_execute(arg_hash); execute_plugins(:pre_compile_execute, arg_hash); end
-  def post_compile_execute(arg_hash); execute_plugins(:post_compile_execute, arg_hash); end
-
-  def pre_link_execute(arg_hash); execute_plugins(:pre_link_execute, arg_hash); end
-  def post_link_execute(arg_hash); execute_plugins(:post_link_execute, arg_hash); end
-
-  def pre_test_fixture_execute(arg_hash); execute_plugins(:pre_test_fixture_execute, arg_hash); end
-  def post_test_fixture_execute(arg_hash)
-    # special arbitration: raw test results are printed or taken over by plugins handling the job
-    @streaminator.stdout_puts(arg_hash[:shell_result][:output]) if (@configurator.plugins_display_raw_test_results)
-    execute_plugins(:post_test_fixture_execute, arg_hash)
-  end
-
-  def pre_test; execute_plugins(:pre_test); end
-  def post_test; execute_plugins(:post_test); end
-
-  def pre_release; execute_plugins(:pre_release); end
-  def post_release; execute_plugins(:post_release); end
-  
-  def pre_build; execute_plugins(:pre_build); end
-  def post_build; execute_plugins(:post_build); end
-  
-  def summary; execute_plugins(:summary); end
-  
-  private ####################################
-  
-  def camelize(underscored_name)
-    return underscored_name.gsub(/(_|^)([a-z0-9])/) {$2.upcase}
-  end
-
-  def execute_plugins(method, *args)
-    @plugin_objects.each do |plugin|
-      begin
-        plugin.send(method, *args)
-      rescue
-        puts "Exception raised in plugin: #{plugin.name}, in method #{method}"
-        raise
-      end
-    end
-  end
-
-end
+require 'set'
+require 'ceedling/constants'
+
+class PluginManager
+
+  constructor :configurator, :plugin_manager_helper, :streaminator, :reportinator, :system_wrapper
+
+  def setup
+    @build_fail_registry = []
+    @plugin_objects = [] # so we can preserve order
+  end
+  
+  def load_plugin_scripts(script_plugins, system_objects)
+    environment = []
+    
+    script_plugins.each do |plugin|
+      # protect against instantiating object multiple times due to processing config multiple times (option files, etc)
+			next if (@plugin_manager_helper.include?(@plugin_objects, plugin))
+      begin
+        @system_wrapper.require_file( "#{plugin}.rb" )
+        object = @plugin_manager_helper.instantiate_plugin_script( camelize(plugin), system_objects, plugin )
+        @plugin_objects << object
+        environment += object.environment
+        
+        # add plugins to hash of all system objects
+        system_objects[plugin.downcase.to_sym] = object
+      rescue
+        puts "Exception raised while trying to load plugin: #{plugin}"
+        raise
+      end
+    end
+    
+    yield( { :environment => environment } ) if (environment.size > 0)
+  end
+  
+  def plugins_failed?
+    return (@build_fail_registry.size > 0)
+  end
+  
+  def print_plugin_failures
+    if (@build_fail_registry.size > 0)
+      report = @reportinator.generate_banner('BUILD FAILURE SUMMARY')
+      
+      @build_fail_registry.each do |failure|
+        report += "#{' - ' if (@build_fail_registry.size > 1)}#{failure}\n"
+      end
+      
+      report += "\n"
+      
+      @streaminator.stderr_puts(report, Verbosity::ERRORS)
+    end    
+  end
+  
+  def register_build_failure(message)
+    @build_fail_registry << message if (message and not message.empty?)
+  end
+
+  #### execute all plugin methods ####
+
+  def pre_mock_generate(arg_hash); execute_plugins(:pre_mock_generate, arg_hash); end
+  def post_mock_generate(arg_hash); execute_plugins(:post_mock_generate, arg_hash); end
+
+  def pre_runner_generate(arg_hash); execute_plugins(:pre_runner_generate, arg_hash); end
+  def post_runner_generate(arg_hash); execute_plugins(:post_runner_generate, arg_hash); end
+
+  def pre_compile_execute(arg_hash); execute_plugins(:pre_compile_execute, arg_hash); end
+  def post_compile_execute(arg_hash); execute_plugins(:post_compile_execute, arg_hash); end
+
+  def pre_link_execute(arg_hash); execute_plugins(:pre_link_execute, arg_hash); end
+  def post_link_execute(arg_hash); execute_plugins(:post_link_execute, arg_hash); end
+
+  def pre_test_fixture_execute(arg_hash); execute_plugins(:pre_test_fixture_execute, arg_hash); end
+  def post_test_fixture_execute(arg_hash)
+    # special arbitration: raw test results are printed or taken over by plugins handling the job
+    @streaminator.stdout_puts(arg_hash[:shell_result][:output]) if (@configurator.plugins_display_raw_test_results)
+    execute_plugins(:post_test_fixture_execute, arg_hash)
+  end
+
+  def pre_test(test); execute_plugins(:pre_test, test); end
+  def post_test(test); execute_plugins(:post_test, test); end
+
+  def pre_release; execute_plugins(:pre_release); end
+  def post_release; execute_plugins(:post_release); end
+  
+  def pre_build; execute_plugins(:pre_build); end
+  def post_build; execute_plugins(:post_build); end
+  
+  def summary; execute_plugins(:summary); end
+  
+  private ####################################
+  
+  def camelize(underscored_name)
+    return underscored_name.gsub(/(_|^)([a-z0-9])/) {$2.upcase}
+  end
+
+  def execute_plugins(method, *args)
+    @plugin_objects.each do |plugin|
+      begin
+        plugin.send(method, *args)
+      rescue
+        puts "Exception raised in plugin: #{plugin.name}, in method #{method}"
+        raise
+      end
+    end
+  end
+
+end