arduino_ci 0.1.10 → 0.1.11

data/exe/arduino_ci_remote.rb.orig

@@ -0,0 +1,216 @@
+#!/usr/bin/env ruby
+require 'arduino_ci'
+require 'set'
+require 'pathname'
+
+WIDTH = 80
+
+@failure_count = 0
+@passfail = proc { |result| result ? "✓" : "✗" }
+
+# terminate after printing any debug info.  TODO: capture debug info
+def terminate(final = nil)
+  puts "Failures: #{@failure_count}"
+  unless @failure_count.zero? || final
+    puts "Last message: #{@arduino_cmd.last_msg}"
+    puts "========== Stdout:"
+    puts @arduino_cmd.last_out
+    puts "========== Stderr:"
+    puts @arduino_cmd.last_err
+  end
+  retcode = @failure_count.zero? ? 0 : 1
+  exit(retcode)
+end
+
+# make a nice status line for an action and react to the action
+def perform_action(message, multiline, mark_fn, on_fail_msg, abort_on_fail)
+  line = "#{message}... "
+  endline = "...#{message} "
+  if multiline
+    puts line
+  else
+    print line
+  end
+  result = yield
+  mark = mark_fn.nil? ? "" : mark_fn.call(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?
+    @failure_count += 1
+    # print out error messaging here if we've captured it
+    terminate if abort_on_fail
+  end
+  result
+end
+
+# Make a nice status for something that defers any failure code until script exit
+def attempt(message, &block)
+  perform_action(message, false, @passfail, 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, @passfail, nil, false, &block)
+end
+
+# Make a nice status for something that kills the script immediately on failure
+def assure(message, &block)
+  perform_action(message, false, @passfail, "This may indicate a problem with ArduinoCI, or your configuration", true, &block)
+end
+
+def inform(message, &block)
+  perform_action(message, false, proc { |x| x }, nil, false, &block)
+end
+
+def inform_multiline(message, &block)
+<<<<<<< HEAD
+  perform_action(message, true, nil, nil, false, &block)
+=======
+  perform_action(message, true, proc { }, nil, false, &block)
+>>>>>>> 30d4a9f... Show file tree when unittests or examples aren't found
+end
+
+# Assure that a platform exists and return its definition
+def assured_platform(purpose, name, config)
+  platform_definition = config.platform_definition(name)
+  assure("Requested #{purpose} platform '#{name}' is defined in 'platforms' YML") do
+    !platform_definition.nil?
+  end
+  platform_definition
+end
+
+# initialize command and config
+config = ArduinoCI::CIConfig.default.from_project_library
+@arduino_cmd = ArduinoCI::ArduinoInstallation.autolocate!
+
+# initialize library under test
+installed_library_path = assure("Installing library under test") { @arduino_cmd.install_local_library(".") }
+library_examples = @arduino_cmd.library_examples(installed_library_path)
+cpp_library = ArduinoCI::CppLibrary.new(installed_library_path, @arduino_cmd.lib_dir)
+inform("Library installed at") { installed_library_path.to_s }
+
+# check GCC
+compilers = config.compilers_to_use
+assure("The set of compilers (#{compilers.length}) isn't empty") { !compilers.empty? }
+compilers.each do |gcc_binary|
+  attempt_multiline("Checking #{gcc_binary} version") do
+    version = cpp_library.gcc_version(gcc_binary)
+    next nil unless version
+
+    puts version.split("\n").map { |l| "    #{l}" }.join("\n")
+    version
+  end
+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
+all_platforms = {}
+aux_libraries = Set.new(config.aux_libraries_for_unittest + config.aux_libraries_for_build)
+# while collecting the platforms, ensure they're defined
+config.platforms_to_unittest.each { |p| all_platforms[p] = assured_platform("unittest", p, config) }
+library_examples.each do |path|
+  ovr_config = config.from_example(path)
+  ovr_config.platforms_to_build.each { |p| all_platforms[p] = assured_platform("library example", p, config) }
+  aux_libraries.merge(ovr_config.aux_libraries_for_build)
+end
+
+# with all platform info, we can extract unique packages and their urls
+# do that, set the URLs, and download the packages
+all_packages = all_platforms.values.map { |v| v[:package] }.uniq.reject(&:nil?)
+all_urls = all_packages.map { |p| config.package_url(p) }.uniq.reject(&:nil?)
+unless all_urls.empty?
+  assure("Setting board manager URLs") do
+    @arduino_cmd.set_pref("boardsmanager.additional.urls", all_urls.join(","))
+  end
+end
+
+all_packages.each do |p|
+  assure("Installing board package #{p}") do
+    @arduino_cmd.install_boards(p)
+  end
+end
+
+aux_libraries.each do |l|
+  if @arduino_cmd.library_present?(l)
+    inform("Using pre-existing library") { l.to_s }
+  else
+    assure("Installing aux library '#{l}'") { @arduino_cmd.install_library(l) }
+  end
+end
+
+# iterate boards / tests
+last_board = nil
+if !cpp_library.tests_dir.exist?
+  inform_multiline("Skipping unit tests; no tests dir at #{cpp_library.tests_dir}") do
+    puts cpp_library.tests_dir.find.to_a.to_s
+    true
+  end
+elsif cpp_library.test_files.empty?
+  inform_multiline("Skipping unit tests; no test files were found in #{cpp_library.tests_dir}") do
+    puts cpp_library.tests_dir.find.to_a.to_s
+    true
+  end
+elsif config.platforms_to_unittest.empty?
+  inform("Skipping unit tests") { "no platforms were requested" }
+else
+  config.platforms_to_unittest.each do |p|
+    board = all_platforms[p][:board]
+    last_board = "arduino:avr:pro:cpu=16MHzatmega328"
+    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 = unittest_path.basename.to_s
+      compilers.each do |gcc_binary|
+        attempt_multiline("Unit testing #{unittest_name} with #{gcc_binary}") do
+          exe = cpp_library.build_for_test_with_configuration(
+            unittest_path,
+            config.aux_libraries_for_unittest,
+            gcc_binary,
+            config.gcc_config(p)
+          )
+          puts
+          unless exe
+            puts "Last command: #{cpp_library.last_cmd}"
+            puts cpp_library.last_out
+            puts cpp_library.last_err
+            next false
+          end
+          cpp_library.run_test_file(exe)
+        end
+      end
+    end
+  end
+end
+
+if library_examples.empty?
+  inform_multiline("Skipping libraries; no examples found in #{installed_library_path}") do
+    puts installed_library_path.find.to_a.to_s
+  end
+else
+  attempt("Setting compiler warning level")  { @arduino_cmd.set_pref("compiler.warning_level", "all") }
+
+  # unlike previous, iterate examples / boards
+  library_examples.each do |example_path|
+    ovr_config = config.from_example(example_path)
+    ovr_config.platforms_to_build.each do |p|
+      board = all_platforms[p][:board]
+      assure("Switching to board for #{p} (#{board})") { @arduino_cmd.use_board(board) } unless last_board == board
+      last_board = board
+      example_name = File.basename(example_path)
+      attempt("Verifying #{example_name}") do
+        ret = @arduino_cmd.verify_sketch(example_path)
+        unless ret
+          puts
+          puts "Last command: #{@arduino_cmd.last_msg}"
+          puts @arduino_cmd.last_err
+        end
+        ret
+      end
+    end
+  end
+end
+
+terminate(true)

data/exe/ensure_arduino_installation.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'arduino_ci'
+
+# this will exit after Arduino is located and/or forcibly installed
+ArduinoCI::ArduinoInstallation.autolocate!

data/lib/arduino_ci/arduino_cmd.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'pathname'
 
 module ArduinoCI
 
@@ -14,7 +15,7 @@ module ArduinoCI
     #   @return [String] the text of the command line flag (`$2` in this case)
     def self.flag(name, text = nil)
       text = "(flag #{name} not defined)" if text.nil?
-      self.class_eval("def flag_#{name};\"#{text}\";end")
+      self.class_eval("def flag_#{name};\"#{text}\";end", __FILE__, __LINE__)
     end
 
     # the path to the Arduino executable
@@ -66,8 +67,8 @@ module ArduinoCI
     end
 
     # @return [String] the path to the Arduino libraries directory
-    def _lib_dir
-      "<lib dir not defined>"
+    def lib_dir
+      Pathname.new(get_pref("sketchbook.path")) + "libraries"
     end
 
     # fetch preferences in their raw form
@@ -75,6 +76,8 @@ module ArduinoCI
     def _prefs_raw
       resp = run_and_capture(flag_get_pref)
       return nil unless resp[:success]
+
+      @prefs_fetched = true
       resp[:out]
     end
 
@@ -83,6 +86,7 @@ module ArduinoCI
     def prefs
       prefs_raw = _prefs_raw unless @prefs_fetched
       return nil if prefs_raw.nil?
+
       @prefs_cache = parse_pref_string(prefs_raw)
       @prefs_cache.clone
     end
@@ -108,23 +112,12 @@ module ArduinoCI
     # @param value [String] the preference value
     # @return [bool] whether the command succeeded
     def set_pref(key, value)
+      prefs unless @prefs_fetched  # update cache first
       success = _set_pref(key, value)
       @prefs_cache[key] = value if success
       success
     end
 
-    # run the arduino command
-    # @return [bool] whether the command succeeded
-    def _run_and_output(*args, **kwargs)
-      raise "Ian needs to implement this in a subclass #{args} #{kwargs}"
-    end
-
-    # 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
@@ -140,13 +133,13 @@ module ArduinoCI
 
     # build and run the arduino command
     def run_and_output(*args, **kwargs)
-      _wrap_run((proc { |*a, **k| _run_and_output(*a, **k) }), *args, **kwargs)
+      _wrap_run((proc { |*a, **k| Host.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)
-      ret = _wrap_run((proc { |*a, **k| _run_and_capture(*a, **k) }), *args, **kwargs)
+      ret = _wrap_run((proc { |*a, **k| Host.run_and_capture(*a, **k) }), *args, **kwargs)
       @last_err = ret[:err]
       @last_out = ret[:out]
       ret
@@ -200,9 +193,20 @@ module ArduinoCI
 
     # generate the (very likely) path of a library given its name
     # @param library_name [String] The name of the library
-    # @return [String] The fully qualified library name
+    # @return [Pathname] The fully qualified library name
     def library_path(library_name)
-      File.join(_lib_dir, library_name)
+      Pathname.new(lib_dir) + library_name
+    end
+
+    # Determine whether a library is present in the lib dir
+    #
+    # Note that `true` doesn't guarantee that the library is valid/installed
+    #  and `false` doesn't guarantee that the library isn't built-in
+    #
+    # @param library_name [String] The name of the library
+    # @return [bool]
+    def library_present?(library_name)
+      library_path(library_name).exist?
     end
 
     # update the library index
@@ -225,9 +229,11 @@ module ArduinoCI
     # @return [bool] whether the command succeeded
     def use_board!(boardname)
       return true if use_board(boardname)
+
       boardfamily = boardname.split(":")[0..1].join(":")
       puts "Board '#{boardname}' not found; attempting to install '#{boardfamily}'"
       return false unless install_boards(boardfamily) # guess board family from first 2 :-separated fields
+
       use_board(boardname)
     end
 
@@ -249,23 +255,24 @@ module ArduinoCI
 
     # ensure that the given library is installed, or symlinked as appropriate
     # return the path of the prepared library, or nil
-    # @param path [String] library to use
+    # @param path [Pathname] library to use
     # @return [String] the path of the installed library
     def install_local_library(path)
-      realpath = File.expand_path(path)
-      library_name = File.basename(realpath)
+      src_path = path.realpath
+      library_name = src_path.basename
       destination_path = library_path(library_name)
 
       # things get weird if the sketchbook contains the library.
       # check that first
-      if File.exist? destination_path
+      if destination_path.exist?
         uhoh = "There is already a library '#{library_name}' in the library directory"
-        return destination_path if destination_path == realpath
+        return destination_path if destination_path == src_path
 
         # maybe it's a symlink? that would be OK
-        if File.symlink?(destination_path)
-          return destination_path if File.readlink(destination_path) == realpath
-          @last_msg = "#{uhoh} and it's not symlinked to #{realpath}"
+        if destination_path.symlink?
+          return destination_path if destination_path.readlink == src_path
+
+          @last_msg = "#{uhoh} and it's not symlinked to #{src_path}"
           return nil
         end
 
@@ -274,19 +281,20 @@ module ArduinoCI
       end
 
       # install the library
-      Host.symlink(realpath, destination_path)
+      Host.symlink(src_path, destination_path)
       destination_path
     end
 
     # @param installed_library_path [String] The library to query
     # @return [Array<String>] Example sketch files
     def library_examples(installed_library_path)
-      example_path = File.join(installed_library_path, "examples")
+      example_path = Pathname.new(installed_library_path) + "examples"
       return [] unless File.exist?(example_path)
-      examples = Pathname.new(example_path).children.select(&:directory?).map(&:to_path).map(&File.method(:basename))
+
+      examples = example_path.children.select(&:directory?).map(&:to_path).map(&File.method(:basename))
       files = examples.map do |e|
-        proj_file = File.join(example_path, e, "#{e}.ino")
-        File.exist?(proj_file) ? proj_file : nil
+        proj_file = example_path + e + "#{e}.ino"
+        proj_file.exist? ? proj_file.to_s : nil
       end
       files.reject(&:nil?)
     end

data/lib/arduino_ci/arduino_cmd_linux.rb

@@ -1,5 +1,5 @@
 require 'arduino_ci/arduino_cmd'
-require 'arduino_ci/display_manager'
+require 'timeout'
 
 module ArduinoCI
 
@@ -19,7 +19,6 @@ module ArduinoCI
     def initialize
       super
       @prefs_response_time = nil
-      @display_mgr         = DisplayManager::instance
     end
 
     # fetch preferences in their raw form
@@ -29,25 +28,8 @@ module ArduinoCI
       resp = run_and_capture(flag_get_pref)
       @prefs_response_time = Time.now - start
       return nil unless resp[:success]
-      resp[:out]
-    end
-
-    # implementation for Arduino library dir location
-    # @return [String] the path to the Arduino libraries directory
-    def _lib_dir
-      File.join(get_pref("sketchbook.path"), "libraries")
-    end
 
-    # run the arduino command
-    # @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)
+      resp[:out]
     end
 
     def run_with_gui_guess(message, *args, **kwargs)

data/lib/arduino_ci/arduino_cmd_linux_builder.rb

@@ -14,24 +14,6 @@ module ArduinoCI
     flag :install_library, "--install-library"   # apparently doesn't exist
     flag :verify,          "-compile"
 
-    # linux-specific implementation
-    # @return [String] The path to the library dir
-    def _lib_dir
-      File.join(get_pref("sketchbook.path"), "libraries")
-    end
-
-    # run the arduino command
-    # @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
 
 end