arduino_ci 0.1.5 → 0.1.6

data/exe/arduino_ci_remote.rb

@@ -21,11 +21,18 @@ def terminate(final = nil)
 end
 
 # make a nice status line for an action and react to the action
-def perform_action(message, on_fail_msg, abort_on_fail)
-  line = "#{message}..."
-  print line
+def perform_action(message, multiline, on_fail_msg, abort_on_fail)
+  line = "#{message}... "
+  endline = "...#{message} "
+  if multiline
+    puts line
+  else
+    print line
+  end
   result = yield
   mark = result ? "✓" : "✗"
+  # if multline, put checkmark at full width
+  print endline if multiline
   puts mark.rjust(WIDTH - line.length, " ")
   unless result
     puts on_fail_msg unless on_fail_msg.nil?
@@ -38,12 +45,17 @@ end
 
 # Make a nice status for something that defers any failure code until script exit
 def attempt(message, &block)
-  perform_action(message, nil, false, &block)
+  perform_action(message, false, nil, false, &block)
+end
+
+# Make a nice status for something that defers any failure code until script exit
+def attempt_multiline(message, &block)
+  perform_action(message, true, nil, false, &block)
 end
 
 # Make a nice status for something that kills the script immediately on failure
 def assure(message, &block)
-  perform_action(message, "This may indicate a problem with ArduinoCI!", true, &block)
+  perform_action(message, false, "This may indicate a problem with ArduinoCI!", true, &block)
 end
 
 # initialize command and config
@@ -56,6 +68,14 @@ library_examples = @arduino_cmd.library_examples(installed_library_path)
 cpp_library = ArduinoCI::CppLibrary.new(installed_library_path)
 attempt("Library installed at #{installed_library_path}") { true }
 
+# check GCC
+attempt_multiline("Checking GCC version") do
+  version = cpp_library.gcc_version
+  next nil unless version
+  puts version.split("\n").map { |l| "    #{l}" }.join("\n")
+  version
+end
+
 # gather up all required boards so we can install them up front.
 # start with the "platforms to unittest" and add the examples
 # while we're doing that, get the aux libraries as well
@@ -97,11 +117,11 @@ elsif config.platforms_to_unittest.empty?
 else
   config.platforms_to_unittest.each do |p|
     board = all_platforms[p][:board]
-    # assure("Switching to board for #{p} (#{board})") { @arduino_cmd.use_board(board) } unless last_board == board
+    assure("Switching to board for #{p} (#{board})") { @arduino_cmd.use_board(board) } unless last_board == board
     last_board = board
     cpp_library.test_files.each do |unittest_path|
       unittest_name = File.basename(unittest_path)
-      attempt("Unit testing #{unittest_name}") do
+      attempt_multiline("Unit testing #{unittest_name}") do
         exe = cpp_library.build_for_test_with_configuration(
           unittest_path,
           config.aux_libraries_for_unittest,

data/lib/arduino_ci/arduino_cmd.rb

@@ -114,12 +114,18 @@ module ArduinoCI
     end
 
     # run the arduino command
-    def _run(*args, **kwargs)
+    # @return [bool] whether the command succeeded
+    def _run_and_output(*args, **kwargs)
       raise "Ian needs to implement this in a subclass #{args} #{kwargs}"
     end
 
-    # build and run the arduino command
-    def run(*args, **kwargs)
+    # run the arduino command
+    # @return [Hash] keys for :success, :out, and :err
+    def _run_and_capture(*args, **kwargs)
+      raise "Ian needs to implement this in a subclass #{args} #{kwargs}"
+    end
+
+    def _wrap_run(work_fn, *args, **kwargs)
       # do some work to extract & merge environment variables if they exist
       has_env = !args.empty? && args[0].class == Hash
       env_vars = has_env ? args[0] : {}
@@ -129,26 +135,21 @@ module ArduinoCI
 
       shell_vars = env_vars.map { |k, v| "#{k}=#{v}" }.join(" ")
       @last_msg = " $ #{shell_vars} #{full_args.join(' ')}"
-      _run(*full_cmd, **kwargs)
+      work_fn.call(*full_cmd, **kwargs)
+    end
+
+    # build and run the arduino command
+    def run_and_output(*args, **kwargs)
+      _wrap_run((proc { |*a, **k| _run_and_output(*a, **k) }), *args, **kwargs)
     end
 
     # run a command and capture its output
     # @return [Hash] {:out => String, :err => String, :success => bool}
     def run_and_capture(*args, **kwargs)
-      pipe_out, pipe_out_wr = IO.pipe
-      pipe_err, pipe_err_wr = IO.pipe
-      our_kwargs = { out: pipe_out_wr, err: pipe_err_wr }
-      eventual_kwargs = our_kwargs.merge(kwargs)
-      success = run(*args, **eventual_kwargs)
-      pipe_out_wr.close
-      pipe_err_wr.close
-      str_out = pipe_out.read
-      str_err = pipe_err.read
-      pipe_out.close
-      pipe_err.close
-      @last_err = str_err
-      @last_out = str_out
-      { out: str_out, err: str_err, success: success }
+      ret = _wrap_run((proc { |*a, **k| _run_and_capture(*a, **k) }), *args, **kwargs)
+      @last_err = ret[:err]
+      @last_out = ret[:out]
+      ret
     end
 
     # run a command and don't capture its output, but use the same signature

data/lib/arduino_ci/arduino_cmd_linux.rb

@@ -39,8 +39,15 @@ module ArduinoCI
     end
 
     # run the arduino command
-    def _run(*args, **kwargs)
-      @display_mgr.run(*args, **kwargs)
+    # @return [bool] whether the command succeeded
+    def _run_and_output(*args, **kwargs)
+      @display_mgr.run_and_output(*args, **kwargs)
+    end
+
+    # run the arduino command
+    # @return [Hash] keys for :success, :out, and :err
+    def _run_and_capture(*args, **kwargs)
+      @display_mgr.run_and_capture(*args, **kwargs)
     end
 
     def run_with_gui_guess(message, *args, **kwargs)

data/lib/arduino_ci/arduino_cmd_linux_builder.rb

@@ -21,10 +21,15 @@ module ArduinoCI
     end
 
     # run the arduino command
-    # @param [Array<String>] Arguments for the run command
-    # @return [bool] Whether the command succeeded
-    def _run(*args, **kwargs)
-      Host.run(*args, **kwargs)
+    # @return [bool] whether the command succeeded
+    def _run_and_output(*args, **kwargs)
+      Host.run_and_output(*args, **kwargs)
+    end
+
+    # run the arduino command
+    # @return [Hash] keys for :success, :out, and :err
+    def _run_and_capture(*args, **kwargs)
+      Host.run_and_capture(*args, **kwargs)
     end
 
   end

data/lib/arduino_ci/arduino_cmd_osx.rb

@@ -14,8 +14,15 @@ module ArduinoCI
     flag :verify,          "--verify"
 
     # run the arduino command
-    def _run(*args, **kwargs)
-      Host.run(*args, **kwargs)
+    # @return [bool] whether the command succeeded
+    def _run_and_output(*args, **kwargs)
+      Host.run_and_output(*args, **kwargs)
+    end
+
+    # run the arduino command
+    # @return [Hash] keys for :success, :out, and :err
+    def _run_and_capture(*args, **kwargs)
+      Host.run_and_capture(*args, **kwargs)
     end
 
     def _lib_dir

data/lib/arduino_ci/ci_config.rb

@@ -200,12 +200,14 @@ module ArduinoCI
     # platforms to build [the examples on]
     # @return [Array<String>] The platforms to build
     def platforms_to_build
+      return [] if @compile_info[:platforms].nil?
       @compile_info[:platforms]
     end
 
     # platforms to unit test [the tests on]
     # @return [Array<String>] The platforms to unit test on
     def platforms_to_unittest
+      return [] if @unittest_info[:platforms].nil?
       @unittest_info[:platforms]
     end
 

data/lib/arduino_ci/cpp_library.rb

@@ -108,23 +108,20 @@ module ArduinoCI
 
     # wrapper for the GCC command
     def run_gcc(*args, **kwargs)
-      pipe_out, pipe_out_wr = IO.pipe
-      pipe_err, pipe_err_wr = IO.pipe
       full_args = ["g++"] + args
       @last_cmd = " $ #{full_args.join(' ')}"
-      our_kwargs = { out: pipe_out_wr, err: pipe_err_wr }
-      eventual_kwargs = our_kwargs.merge(kwargs)
-      success = Host.run(*full_args, **eventual_kwargs)
 
-      pipe_out_wr.close
-      pipe_err_wr.close
-      str_out = pipe_out.read
-      str_err = pipe_err.read
-      pipe_out.close
-      pipe_err.close
-      @last_err = str_err
-      @last_out = str_out
-      success
+      ret = Host.run_and_capture(*full_args, **kwargs)
+      @last_err = ret[:err]
+      @last_out = ret[:out]
+      ret[:success]
+    end
+
+    # Return the GCC version
+    # @return [String] the version reported by `gcc -v`
+    def gcc_version
+      return nil unless run_gcc("-v")
+      @last_err
     end
 
     # GCC command line arguments for including aux libraries
@@ -207,7 +204,7 @@ module ArduinoCI
       @last_cmd = executable
       @last_out = ""
       @last_err = ""
-      Host.run(executable)
+      Host.run_and_output(executable)
     end
 
   end

data/lib/arduino_ci/cpp_library.rb.orig

@@ -0,0 +1,215 @@
+require 'find'
+require "arduino_ci/host"
+
+HPP_EXTENSIONS = [".hpp", ".hh", ".h", ".hxx", ".h++"].freeze
+CPP_EXTENSIONS = [".cpp", ".cc", ".c", ".cxx", ".c++"].freeze
+ARDUINO_HEADER_DIR = File.expand_path("../../../cpp/arduino", __FILE__)
+UNITTEST_HEADER_DIR = File.expand_path("../../../cpp/unittest", __FILE__)
+
+module ArduinoCI
+
+  # Information about an Arduino CPP library, specifically for compilation purposes
+  class CppLibrary
+
+    # @return [String] The path to the library being tested
+    attr_reader :base_dir
+
+    # @return [Array<String>] The set of artifacts created by this class (note: incomplete!)
+    attr_reader :artifacts
+
+    # @return [String] STDERR from the last command
+    attr_reader :last_err
+
+    # @return [String] STDOUT from the last command
+    attr_reader :last_out
+
+    # @return [String] the last command
+    attr_reader :last_cmd
+
+    # @param base_dir [String] The path to the library being tested
+    def initialize(base_dir)
+      @base_dir = File.expand_path(base_dir)
+      @artifacts = []
+      @last_err = ""
+      @last_out = ""
+      @last_msg = ""
+    end
+
+    # Guess whether a file is part of the vendor bundle (indicating we should ignore it).
+    #
+    # This assumes the vendor bundle will be at `vendor/bundle` and not some other location
+    # @param path [String] The path to check
+    # @return [Array<String>] The paths of the found files
+    def vendor_bundle?(path)
+      # TODO: look for Gemfile, look for .bundle/config and get BUNDLE_PATH from there?
+      base = File.join(@base_dir, "vendor")
+      real = File.join(File.realpath(@base_dir), "vendor")
+      return true if path.start_with?(base)
+      return true if path.start_with?(real)
+      false
+    end
+
+    # Get a list of all CPP source files in a directory and its subdirectories
+    # @param some_dir [String] The directory in which to begin the search
+    # @return [Array<String>] The paths of the found files
+    def cpp_files_in(some_dir)
+      return [] unless File.exist?(some_dir)
+      real = File.realpath(some_dir)
+      files = Find.find(real).reject { |path| File.directory?(path) }
+      ret = files.select { |path| CPP_EXTENSIONS.include?(File.extname(path)) }
+      ret
+    end
+
+    # CPP files that are part of the project library under test
+    # @return [Array<String>]
+    def cpp_files
+      real_tests_dir = File.realpath(tests_dir)
+      cpp_files_in(@base_dir).reject do |p|
+        next true if File.dirname(p).include?(tests_dir)
+        next true if File.dirname(p).include?(real_tests_dir)
+        next true if vendor_bundle?(p)
+      end
+    end
+
+    # CPP files that are part of the arduino mock library we're providing
+    # @return [Array<String>]
+    def cpp_files_arduino
+      cpp_files_in(ARDUINO_HEADER_DIR)
+    end
+
+    # CPP files that are part of the unit test library we're providing
+    # @return [Array<String>]
+    def cpp_files_unittest
+      cpp_files_in(UNITTEST_HEADER_DIR)
+    end
+
+    # The directory where we expect to find unit test defintions provided by the user
+    # @return [String]
+    def tests_dir
+      File.join(@base_dir, "test")
+    end
+
+    # The files provided by the user that contain unit tests
+    # @return [Array<String>]
+    def test_files
+      cpp_files_in(tests_dir)
+    end
+
+    # Find all directories in the project library that include C++ header files
+    # @return [Array<String>]
+    def header_dirs
+      real = File.realpath(@base_dir)
+      all_files = Find.find(real).reject { |path| File.directory?(path) }
+      unbundled = all_files.reject { |path| vendor_bundle?(path) }
+      files = unbundled.select { |path| HPP_EXTENSIONS.include?(File.extname(path)) }
+      ret = files.map { |path| File.dirname(path) }.uniq
+      ret
+    end
+
+    # wrapper for the GCC command
+    def run_gcc(*args, **kwargs)
+      full_args = ["g++-4.9"] + args
+      @last_cmd = " $ #{full_args.join(' ')}"
+<<<<<<< Updated upstream
+
+=======
+>>>>>>> Stashed changes
+      ret = Host.run_and_capture(*full_args, **kwargs)
+      @last_err = ret[:err]
+      @last_out = ret[:out]
+      ret[:success]
+    end
+
+    # Return the GCC version
+    # @return [String] the version reported by `gcc -v`
+    def gcc_version
+      return nil unless run_gcc("-v")
+      @last_err
+    end
+
+    # GCC command line arguments for including aux libraries
+    # @param aux_libraries [String] The external Arduino libraries required by this project
+    # @return [Array<String>] The GCC command-line flags necessary to include those libraries
+    def include_args(aux_libraries)
+      places = [ARDUINO_HEADER_DIR, UNITTEST_HEADER_DIR] + header_dirs + aux_libraries
+      places.map { |d| "-I#{d}" }
+    end
+
+    # GCC command line arguments for features (e.g. -fno-weak)
+    # @param ci_gcc_config [Hash] The GCC config object
+    # @return [Array<String>] GCC command-line flags
+    def feature_args(ci_gcc_config)
+      return [] if ci_gcc_config[:features].nil?
+      ci_gcc_config[:features].map { |f| "-f#{f}" }
+    end
+
+    # GCC command line arguments for warning (e.g. -Wall)
+    # @param ci_gcc_config [Hash] The GCC config object
+    # @return [Array<String>] GCC command-line flags
+    def warning_args(ci_gcc_config)
+      return [] if ci_gcc_config[:warnings].nil?
+      ci_gcc_config[:features].map { |w| "-W#{w}" }
+    end
+
+    # GCC command line arguments for defines (e.g. -Dhave_something)
+    # @param ci_gcc_config [Hash] The GCC config object
+    # @return [Array<String>] GCC command-line flags
+    def define_args(ci_gcc_config)
+      return [] if ci_gcc_config[:defines].nil?
+      ci_gcc_config[:defines].map { |d| "-D#{d}" }
+    end
+
+    # GCC command line arguments as-is
+    # @param ci_gcc_config [Hash] The GCC config object
+    # @return [Array<String>] GCC command-line flags
+    def flag_args(ci_gcc_config)
+      return [] if ci_gcc_config[:flags].nil?
+      ci_gcc_config[:flags]
+    end
+
+    # All GCC command line args for building any unit test
+    # @param aux_libraries [String] The external Arduino libraries required by this project
+    # @param ci_gcc_config [Hash] The GCC config object
+    # @return [Array<String>] GCC command-line flags
+    def test_args(aux_libraries, ci_gcc_config)
+      # TODO: something with libraries?
+      ret = include_args(aux_libraries) + cpp_files_arduino + cpp_files_unittest + cpp_files
+      unless ci_gcc_config.nil?
+        cgc = ci_gcc_config
+        ret = feature_args(cgc) + warning_args(cgc) + define_args(cgc) + flag_args(cgc) + ret
+      end
+      ret
+    end
+
+    # build a file for running a test of the given unit test file
+    # @param test_file [String] The path to the file containing the unit tests
+    # @param aux_libraries [String] The external Arduino libraries required by this project
+    # @param ci_gcc_config [Hash] The GCC config object
+    # @return [String] path to the compiled test executable
+    def build_for_test_with_configuration(test_file, aux_libraries, ci_gcc_config)
+      base = File.basename(test_file)
+      executable = File.expand_path("unittest_#{base}.bin")
+      File.delete(executable) if File.exist?(executable)
+      args = [
+        ["-std=c++0x", "-o", executable, "-DARDUINO=100"],
+        test_args(aux_libraries, ci_gcc_config),
+        [test_file],
+      ].flatten(1)
+      return nil unless run_gcc(*args)
+      artifacts << executable
+      executable
+    end
+
+    # run a test file
+    # @param [String] the path to the test file
+    # @return [bool] whether all tests were successful
+    def run_test_file(executable)
+      @last_cmd = executable
+      @last_out = ""
+      @last_err = ""
+      Host.run_and_output(executable)
+    end
+
+  end
+
+end