arduino_ci 0.1.21 → 1.0.0

data/exe/arduino_library_location.rb

@@ -2,6 +2,6 @@
 require 'arduino_ci'
 
 # locate and/or forcibly install Arduino, keep stdout clean
-@arduino_cmd = ArduinoCI::ArduinoInstallation.autolocate!($stderr)
+@backend = ArduinoCI::ArduinoInstallation.autolocate!($stderr)
 
-puts @arduino_cmd.lib_dir
+puts @backend.lib_dir

data/lib/arduino_ci.rb

@@ -2,6 +2,7 @@ require "arduino_ci/version"
 require "arduino_ci/arduino_installation"
 require "arduino_ci/cpp_library"
 require "arduino_ci/ci_config"
+require "arduino_ci/library_properties"
 
 # ArduinoCI contains classes for automated testing of Arduino code on the command line
 # @author Ian Katz <ianfixes@gmail.com>

data/lib/arduino_ci/arduino_backend.rb

@@ -0,0 +1,218 @@
+require 'fileutils'
+require 'pathname'
+require 'json'
+
+# workaround for https://github.com/arduino/Arduino/issues/3535
+WORKAROUND_LIB = "USBHost".freeze
+
+module ArduinoCI
+
+  # To report errors that we can't resolve or possibly even explain
+  class ArduinoExecutionError < StandardError; end
+
+  # Wrap the Arduino executable.  This requires, in some cases, a faked display.
+  class ArduinoBackend
+
+    # We never even use this in code, it's just here for reference because the backend is picky about it. Used for testing
+    # @return [String] the only allowable name for the arduino-cli config file.
+    CONFIG_FILE_NAME = "arduino-cli.yaml".freeze
+
+    # the actual path to the executable on this platform
+    # @return [Pathname]
+    attr_accessor :binary_path
+
+    # If a custom config is deired (i.e. for testing), specify it here.
+    # Note https://github.com/arduino/arduino-cli/issues/753 : the --config-file option
+    # is really the director that contains the file
+    # @return [Pathname]
+    attr_accessor :config_dir
+
+    # @return [String] STDOUT of the most recently-run command
+    attr_reader   :last_out
+
+    # @return [String] STDERR of the most recently-run command
+    attr_reader   :last_err
+
+    # @return [String] the most recently-run command
+    attr_reader   :last_msg
+
+    # @return [Array<String>] Additional URLs for the boards manager
+    attr_reader   :additional_urls
+
+    def initialize(binary_path)
+      @binary_path        = binary_path
+      @config_dir         = nil
+      @additional_urls    = []
+      @last_out           = ""
+      @last_err           = ""
+      @last_msg           = ""
+    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] : {}
+      actual_args = has_env ? args[1..-1] : args  # need to shift over if we extracted args
+      custom_config = @config_dir.nil? ? [] : ["--config-file", @config_dir.to_s]
+      full_args = [binary_path.to_s, "--format", "json"] + custom_config + actual_args
+      full_cmd = env_vars.empty? ? full_args : [env_vars] + full_args
+
+      shell_vars = env_vars.map { |k, v| "#{k}=#{v}" }.join(" ")
+      @last_msg = " $ #{shell_vars} #{full_args.join(' ')}"
+      work_fn.call(*full_cmd, **kwargs)
+    end
+
+    # build and run the arduino command
+    def run_and_output(*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| Host.run_and_capture(*a, **k) }), *args, **kwargs)
+      @last_err = ret[:err]
+      @last_out = ret[:out]
+      ret
+    end
+
+    def capture_json(*args, **kwargs)
+      ret = run_and_capture(*args, **kwargs)
+      ret[:json] = JSON.parse(ret[:out])
+      ret
+    end
+
+    # Get a dump of the entire config
+    # @return [Hash] The configuration
+    def config_dump
+      capture_json("config", "dump")[:json]
+    end
+
+    # @return [String] the path to the Arduino libraries directory
+    def lib_dir
+      Pathname.new(config_dump["directories"]["user"]) + "libraries"
+    end
+
+    # Board manager URLs
+    # @return [Array<String>] The additional URLs used by the board manager
+    def board_manager_urls
+      config_dump["board_manager"]["additional_urls"] + @additional_urls
+    end
+
+    # Set board manager URLs
+    # @return [Array<String>] The additional URLs used by the board manager
+    def board_manager_urls=(all_urls)
+      raise ArgumentError("all_urls should be an array, got #{all_urls.class}") unless all_urls.is_a? Array
+
+      @additional_urls = all_urls
+    end
+
+    # check whether a board is installed
+    # we do this by just selecting a board.
+    #   the arduino binary will error if unrecognized and do a successful no-op if it's installed
+    # @param boardname [String] The board to test
+    # @return [bool] Whether the board is installed
+    def board_installed?(boardname)
+      # capture_json("core", "list")[:json].find { |b| b["ID"] == boardname } # nope, this is for the family
+      run_and_capture("board", "details", "--fqbn", boardname)[:success]
+    end
+
+    # install a board by name
+    # @param name [String] the board name
+    # @return [bool] whether the command succeeded
+    def install_boards(boardfamily)
+      result = run_and_capture("core", "install", boardfamily)
+      result[:success]
+    end
+
+    # @return [Hash] information about installed libraries via the CLI
+    def installed_libraries
+      capture_json("lib", "list")[:json]
+    end
+
+    # @param path [String] The sketch to compile
+    # @param boardname [String] The board to use
+    # @return [bool] whether the command succeeded
+    def compile_sketch(path, boardname)
+      ext = File.extname path
+      unless ext.casecmp(".ino").zero?
+        @last_msg = "Refusing to compile sketch with '#{ext}' extension -- rename it to '.ino'!"
+        return false
+      end
+      unless File.exist? path
+        @last_msg = "Can't compile Sketch at nonexistent path '#{path}'!"
+        return false
+      end
+      ret = run_and_capture("compile", "--fqbn", boardname, "--warnings", "all", "--dry-run", path.to_s)
+      ret[:success]
+    end
+
+    # Guess the name of a library
+    # @param path [Pathname] The path to the library (installed or not)
+    # @return [String] the probable library name
+    def name_of_library(path)
+      src_path = path.realpath
+      properties_file = src_path + CppLibrary::LIBRARY_PROPERTIES_FILE
+      return src_path.basename.to_s unless properties_file.exist?
+      return src_path.basename.to_s if LibraryProperties.new(properties_file).name.nil?
+
+      LibraryProperties.new(properties_file).name
+    end
+
+    # Create a handle to an Arduino library by name
+    # @param name [String] The library "real name"
+    # @return [CppLibrary] The library object
+    def library_of_name(name)
+      raise ArgumentError, "name is not a String (got #{name.class})" unless name.is_a? String
+
+      CppLibrary.new(name, self)
+    end
+
+    # Create a handle to an Arduino library by path
+    # @param path [Pathname] The path to the library
+    # @return [CppLibrary] The library object
+    def library_of_path(path)
+      # the path must exist... and if it does, brute-force search the installed libs for it
+      realpath = path.realpath  # should produce error if the path doesn't exist to begin with
+      entry = installed_libraries.find { |l| Pathname.new(l["library"]["install_dir"]).realpath == realpath }
+      probable_name = entry["real_name"].nil? ? realpath.basename.to_s : entry["real_name"]
+      CppLibrary.new(probable_name, self)
+    end
+
+    # install a library from a path on the local machine (not via library manager), by symlink or no-op as appropriate
+    # @param path [Pathname] library to use
+    # @return [CppLibrary] the installed library, or nil
+    def install_local_library(path)
+      src_path         = path.realpath
+      library_name     = name_of_library(path)
+      cpp_library      = library_of_name(library_name)
+      destination_path = cpp_library.path
+
+      # things get weird if the sketchbook contains the library.
+      # check that first
+      if cpp_library.installed?
+        # maybe the project has always lived in the libraries directory, no need to symlink
+        return cpp_library if destination_path == src_path
+
+        uhoh = "There is already a library '#{library_name}' in the library directory (#{destination_path})"
+        # maybe it's a symlink? that would be OK
+        if Host.symlink?(destination_path)
+          current_destination_target = Host.readlink(destination_path)
+          return cpp_library if current_destination_target == src_path
+
+          @last_msg = "#{uhoh} and it's symlinked to #{current_destination_target} (expected #{src_path})"
+          return nil
+        end
+
+        @last_msg = "#{uhoh}.  It may need to be removed manually."
+        return nil
+      end
+
+      # install the library
+      libraries_dir = destination_path.parent
+      libraries_dir.mkpath unless libraries_dir.exist?
+      Host.symlink(src_path, destination_path)
+      cpp_library
+    end
+  end
+end

data/lib/arduino_ci/arduino_downloader.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'pathname'
 require 'net/http'
 require 'open-uri'
 require 'zip'
@@ -10,10 +11,10 @@ module ArduinoCI
   # Manage the OS-specific download & install of Arduino
   class ArduinoDownloader
 
-    # @param desired_ide_version [string] Version string e.g. 1.8.7
+    # @param desired_version [string] Version string e.g. 1.8.7
     # @param output [IO] $stdout, $stderr, File.new(/dev/null, 'w'), etc. where console output will be sent
-    def initialize(desired_ide_version, output = $stdout)
-      @desired_ide_version = desired_ide_version
+    def initialize(desired_version, output = $stdout)
+      @desired_version = desired_version
       @output = output
     end
 
@@ -30,7 +31,7 @@ module ArduinoCI
 
     # The autolocated executable of the installation
     #
-    # @return [string] or nil
+    # @return [Pathname] or nil
     def self.autolocated_executable
       # Arbitrarily, I'm going to pick the force installed location first
       # if it exists.  I'm not sure why we would have both, but if we did
@@ -39,70 +40,54 @@ module ArduinoCI
       locations.find { |loc| !loc.nil? && File.exist?(loc) }
     end
 
-    # The autolocated directory of the installation
-    #
-    # @return [string] or nil
-    def self.autolocated_installation
-      # Arbitrarily, I'm going to pick the force installed location first
-      # if it exists.  I'm not sure why we would have both, but if we did
-      # a force install then let's make sure we actually use it.
-      locations = [self.force_install_location, self.existing_installation]
-      locations.find { |loc| !loc.nil? && File.exist?(loc) }
+    # The executable Arduino file in an existing installation, or nil
+    # @return [Pathname]
+    def self.existing_executable
+      self.must_implement(__method__)
     end
 
-    # The path to the directory of an existing installation, or nil
+    # The local file (dir) name of the desired IDE package (zip/tar/etc)
     # @return [string]
-    def self.existing_installation
-      self.must_implement(__method__)
+    def package_file
+      self.class.must_implement(__method__)
     end
 
-    # The executable Arduino file in an existing installation, or nil
+    # The local filename of the extracted IDE package (zip/tar/etc)
     # @return [string]
-    def self.existing_executable
+    def self.extracted_file
       self.must_implement(__method__)
     end
 
     # The executable Arduino file in a forced installation, or nil
-    # @return [string]
+    # @return [Pathname]
     def self.force_installed_executable
-      self.must_implement(__method__)
+      Pathname.new(ENV['HOME']) + self.extracted_file
     end
 
     # The technology that will be used to complete the download
     # (for logging purposes)
     # @return [string]
-    def downloader
+    def self.downloader
       "open-uri"
     end
 
     # The technology that will be used to extract the download
     # (for logging purposes)
     # @return [string]
-    def extracter
-      "Zip"
-    end
-
-    # The URL of the desired IDE package (zip/tar/etc) for this platform
-    # @return [string]
-    def package_url
-      "https://downloads.arduino.cc/#{package_file}"
+    def self.extracter
+      self.must_implement(__method__)
     end
 
-    # The local file (dir) name of the desired IDE package (zip/tar/etc)
-    # @return [string]
-    def package_file
-      self.class.must_implement(__method__)
+    # Extract the package_file to extracted_file
+    # @return [bool] whether successful
+    def self.extract(_package_file)
+      self.must_implement(__method__)
     end
 
-    # The local filename of the extracted IDE package (zip/tar/etc)
+    # The URL of the desired IDE package (zip/tar/etc) for this platform
     # @return [string]
-    def extracted_file
-      self.class.must_implement(__method__)
-    end
-
-    # @return [String] The location where a forced install will go
-    def self.force_install_location
-      File.join(ENV['HOME'], 'arduino_ci_ide')
+    def package_url
+      "https://github.com/arduino/arduino-cli/releases/download/#{@desired_version}/#{package_file}"
     end
 
     # Download the package_url to package_file
@@ -130,26 +115,10 @@ module ArduinoCI
       @output.puts "\nArduino force-install failed downloading #{package_url}: #{e}"
     end
 
-    # Extract the package_file to extracted_file
-    # @return [bool] whether successful
-    def extract
-      Zip::File.open(package_file) do |zip|
-        batch_size = [1, (zip.size / 100).to_i].max
-        dots = 0
-        zip.each do |file|
-          @output.print "." if (dots % batch_size).zero?
-          file.restore_permissions = true
-          file.extract { accept_all }
-          dots += 1
-        end
-      end
-    end
-
-    # Move the extracted package file from extracted_file to the force_install_location
+    # Move the extracted package file from extracted_file to the force_installed_executable
     # @return [bool] whether successful
     def install
-      # Move only the content of the directory
-      FileUtils.mv extracted_file, self.class.force_install_location
+      FileUtils.mv self.class.extracted_file.to_s, self.class.force_installed_executable.to_s
     end
 
     # Forcibly install Arduino on linux from the web
@@ -161,39 +130,40 @@ module ArduinoCI
         return false
       end
 
+      arduino_package = "Arduino #{@desired_version} package"
       attempts = 0
 
       loop do
-        if File.exist? package_file
-          @output.puts "Arduino package seems to have been downloaded already" if attempts.zero?
+        if File.exist?(package_file)
+          @output.puts "#{arduino_package} seems to have been downloaded already at #{package_file}" if attempts.zero?
           break
         elsif attempts >= DOWNLOAD_ATTEMPTS
           break @output.puts "After #{DOWNLOAD_ATTEMPTS} attempts, failed to download #{package_url}"
         else
-          @output.print "Attempting to download Arduino package with #{downloader}"
+          @output.print "Attempting to download #{arduino_package} with #{self.class.downloader}"
           download
           @output.puts
         end
         attempts += 1
       end
 
-      if File.exist? extracted_file
-        @output.puts "Arduino package seems to have been extracted already"
-      elsif File.exist? package_file
-        @output.print "Extracting archive with #{extracter}"
-        extract
+      if File.exist?(self.class.extracted_file)
+        @output.puts "#{arduino_package} seems to have been extracted already at #{self.class.extracted_file}"
+      elsif File.exist?(package_file)
+        @output.print "Extracting archive with #{self.class.extracter}"
+        self.class.extract(package_file)
         @output.puts
       end
 
-      if File.exist? self.class.force_install_location
-        @output.puts "Arduino package seems to have been installed already"
-      elsif File.exist? extracted_file
+      if File.exist?(self.class.force_installed_executable)
+        @output.puts "#{arduino_package} seems to have been installed already at #{self.class.force_installed_executable}"
+      elsif File.exist?(self.class.extracted_file)
         install
       else
-        @output.puts "Could not find extracted archive (tried #{extracted_file})"
+        @output.puts "Could not find extracted archive (tried #{self.class.extracted_file})"
       end
 
-      File.exist? self.class.force_install_location
+      File.exist?(self.class.force_installed_executable)
     end
 
   end

data/lib/arduino_ci/arduino_downloader_linux.rb

@@ -1,7 +1,5 @@
 require "arduino_ci/arduino_downloader"
 
-USE_BUILDER = false
-
 module ArduinoCI
 
   # Manage the linux download & install of Arduino
@@ -10,13 +8,25 @@ module ArduinoCI
     # The local filename of the desired IDE package (zip/tar/etc)
     # @return [string]
     def package_file
-      "#{extracted_file}-linux64.tar.xz"
+      "arduino-cli_#{@desired_version}_Linux_64bit.tar.gz"
+    end
+
+    # The local file (dir) name of the extracted IDE package (zip/tar/etc)
+    # @return [string]
+    def self.extracted_file
+      "arduino-cli"
+    end
+
+    # The executable Arduino file in an existing installation, or nil
+    # @return [string]
+    def self.existing_executable
+      Host.which("arduino-cli")
     end
 
     # Make any preparations or run any checks prior to making changes
     # @return [string] Error message, or nil if success
     def prepare
-      reqs = [extracter]
+      reqs = [self.class.extracter]
       reqs.each do |req|
         return "#{req} does not appear to be installed!" unless Host.which(req)
       end
@@ -26,62 +36,14 @@ module ArduinoCI
     # The technology that will be used to extract the download
     # (for logging purposes)
     # @return [string]
-    def extracter
+    def self.extracter
       "tar"
     end
 
     # Extract the package_file to extracted_file
     # @return [bool] whether successful
-    def extract
-      system(extracter, "xf", package_file)
-    end
-
-    # The local file (dir) name of the extracted IDE package (zip/tar/etc)
-    # @return [string]
-    def extracted_file
-      "arduino-#{@desired_ide_version}"
-    end
-
-    # The path to the directory of an existing installation, or nil
-    # @return [string]
-    def self.existing_installation
-      exe = self.existing_executable
-      return nil if exe.nil?
-
-      File.dirname(exe) # it's not really this
-      # but for this platform it doesn't really matter
-    end
-
-    # The executable Arduino file in an existing installation, or nil
-    # @return [string]
-    def self.existing_executable
-      if USE_BUILDER
-        # builder_name = "arduino-builder"
-        # cli_place = Host.which(builder_name)
-        # unless cli_place.nil?
-        #   ret = ArduinoCmdLinuxBuilder.new
-        #   ret.base_cmd = [cli_place]
-        #   return ret
-        # end
-      end
-      Host.which("arduino")
-    end
-
-    # The executable Arduino file in a forced installation, or nil
-    # @return [string]
-    def self.force_installed_executable
-      if USE_BUILDER
-        # forced_builder = File.join(ArduinoCmdLinuxBuilder.force_install_location, builder_name)
-        # if File.exist?(forced_builder)
-        #   ret = ArduinoCmdLinuxBuilder.new
-        #   ret.base_cmd = [forced_builder]
-        #   return ret
-        # end
-      end
-      forced_arduino = File.join(self.force_install_location, "arduino")
-      return forced_arduino if File.exist? forced_arduino
-
-      nil
+    def self.extract(package_file)
+      system(extracter, "xf", package_file, extracted_file)
     end
 
   end