arduino_ci 0.0.1 → 0.1.0

data/lib/arduino_ci/arduino_cmd_linux.rb

@@ -0,0 +1,86 @@
+require 'arduino_ci/arduino_cmd'
+require 'arduino_ci/display_manager'
+
+module ArduinoCI
+
+  # Implementation of Arduino linux IDE commands
+  class ArduinoCmdLinux < ArduinoCmd
+
+    attr_reader :prefs_response_time
+
+    flag :get_pref,        "--get-pref"
+    flag :set_pref,        "--pref"
+    flag :save_prefs,      "--save-prefs"
+    flag :use_board,       "--board"
+    flag :install_boards,  "--install-boards"
+    flag :install_library, "--install-library"
+    flag :verify,          "--verify"
+
+    def initialize
+      super
+      @prefs_response_time = nil
+      @display_mgr         = DisplayManager::instance
+    end
+
+    # fetch preferences in their raw form
+    # @return [String] Preferences as a set of lines
+    def _prefs_raw
+      start = Time.now
+      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
+    def _run(*args, **kwargs)
+      @display_mgr.run(*args, **kwargs)
+    end
+
+    def run_with_gui_guess(message, *args, **kwargs)
+      # On Travis CI, we get an error message in the GUI instead of on STDERR
+      # so, assume that if we don't get a rapid reply that things are not installed
+
+      prefs if @prefs_response_time.nil?
+      x3 = @prefs_response_time * 3
+      Timeout.timeout(x3) do
+        result = run_and_capture(*args, **kwargs)
+        result[:success]
+      end
+    rescue Timeout::Error
+      puts "No response in #{x3} seconds. Assuming graphical modal error message#{message}."
+      false
+    end
+
+    # underlying preference-setter.
+    # @param key [String] the preference key
+    # @param value [String] the preference value
+    # @return [bool] whether the command succeeded
+    def _set_pref(key, value)
+      run_with_gui_guess(" about preferences", flag_set_pref, "#{key}=#{value}", flag_save_prefs)
+    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 name of the board
+    # @return [bool]
+    def board_installed?(boardname)
+      run_with_gui_guess(" about board not installed", flag_use_board, boardname)
+    end
+
+    # use a particular board for compilation
+    # @param boardname [String] The name of the board
+    def use_board(boardname)
+      run_with_gui_guess(" about board not installed", flag_use_board, boardname, flag_save_prefs)
+    end
+
+  end
+
+end

data/lib/arduino_ci/arduino_cmd_linux_builder.rb

@@ -0,0 +1,32 @@
+require "arduino_ci/host"
+require 'arduino_ci/arduino_cmd'
+
+module ArduinoCI
+
+  # Implementation of Arduino linux CLI commands
+  class ArduinoCmdLinuxBuilder < ArduinoCmd
+
+    flag :get_pref,        "--get-pref"          # apparently doesn't exist
+    flag :set_pref,        "--pref"              # apparently doesn't exist
+    flag :save_prefs,      "--save-prefs"        # apparently doesn't exist
+    flag :use_board,       "-fqbn"
+    flag :install_boards,  "--install-boards"    # apparently doesn't exist
+    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
+    # @param [Array<String>] Arguments for the run command
+    # @return [bool] Whether the command succeeded
+    def _run(*args, **kwargs)
+      Host.run(*args, **kwargs)
+    end
+
+  end
+
+end

data/lib/arduino_ci/arduino_cmd_osx.rb

@@ -0,0 +1,27 @@
+require "arduino_ci/host"
+require 'arduino_ci/arduino_cmd'
+
+module ArduinoCI
+
+  # Implementation of OSX commands
+  class ArduinoCmdOSX < ArduinoCmd
+    flag :get_pref,        "--get-pref"
+    flag :set_pref,        "--pref"
+    flag :save_prefs,      "--save-prefs"
+    flag :use_board,       "--board"
+    flag :install_boards,  "--install-boards"
+    flag :install_library, "--install-library"
+    flag :verify,          "--verify"
+
+    # run the arduino command
+    def _run(*args, **kwargs)
+      Host.run(*args, **kwargs)
+    end
+
+    def _lib_dir
+      File.join(ENV['HOME'], "Documents", "Arduino", "libraries")
+    end
+
+  end
+
+end

data/lib/arduino_ci/arduino_installation.rb

@@ -0,0 +1,135 @@
+require "arduino_ci/host"
+require "arduino_ci/arduino_cmd_osx"
+require "arduino_ci/arduino_cmd_linux"
+require "arduino_ci/arduino_cmd_linux_builder"
+
+DESIRED_ARDUINO_IDE_VERSION = "1.8.5".freeze
+USE_BUILDER = false
+
+module ArduinoCI
+
+  # Manage the OS-specific install location of Arduino
+  class ArduinoInstallation
+
+    class << self
+      # @return [String] The location where a forced install will go
+      def force_install_location
+        File.join(ENV['HOME'], 'arduino_ci_ide')
+      end
+
+      # attempt to find a workable Arduino executable across platforms
+      # @return [ArduinoCI::ArduinoCmd] an instance of the command
+      def autolocate
+        case Host.os
+        when :osx then autolocate_osx
+        when :linux then autolocate_linux
+        end
+      end
+
+      # @return [ArduinoCI::ArduinoCmdOSX] an instance of a command
+      def autolocate_osx
+        osx_root = "/Applications/Arduino.app/Contents"
+        old_way = false
+        return nil unless File.exist? osx_root
+
+        ret = ArduinoCmdOSX.new
+        osx_place = "#{osx_root}/MacOS"
+
+        if old_way
+          ret.base_cmd = [File.join(osx_place, "Arduino")]
+        else
+          jvm_runtime = `/usr/libexec/java_home`
+          ret.base_cmd = [
+            "java",
+            "-cp", "#{osx_root}/Java/*",
+            "-DAPP_DIR=#{osx_root}/Java",
+            "-Djava.ext.dirs=$JVM_RUNTIME/Contents/Home/lib/ext/:#{jvm_runtime}/Contents/Home/jre/lib/ext/",
+            "-Dfile.encoding=UTF-8",
+            "-Dapple.awt.UIElement=true",
+            "-Xms128M",
+            "-Xmx512M",
+            "processing.app.Base",
+          ]
+        end
+        ret
+      end
+
+      # @return [ArduinoCI::ArduinoCmdLinux] an instance of a command
+      def autolocate_linux
+        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
+
+          forced_builder = File.join(force_install_location, builder_name)
+          if File.exist?(forced_builder)
+            ret = ArduinoCmdLinuxBuilder.new
+            ret.base_cmd = [forced_builder]
+            return ret
+          end
+        end
+
+        gui_name = "arduino"
+        gui_place = Host.which(gui_name)
+        unless gui_place.nil?
+          ret = ArduinoCmdLinux.new
+          ret.base_cmd = [gui_place]
+          return ret
+        end
+
+        forced_arduino = File.join(force_install_location, gui_name)
+        if File.exist?(forced_arduino)
+          ret = ArduinoCmdLinux.new
+          ret.base_cmd = [forced_arduino]
+          return ret
+        end
+        nil
+      end
+
+      # Attempt to find a workable Arduino executable across platforms, and install it if we don't
+      # @return [ArduinoCI::ArduinoCmd] an instance of a command
+      def autolocate!
+        candidate = autolocate
+        return candidate unless candidate.nil?
+
+        # force the install
+        force_install
+        autolocate
+      end
+
+      # Forcibly install Arduino from the web
+      # @return [bool] Whether the command succeeded
+      def force_install
+        case Host.os
+        when :linux
+          pkgname = "arduino-#{DESIRED_ARDUINO_IDE_VERSION}"
+          tarfile = "#{pkgname}-linux64.tar.xz"
+          if File.exist? tarfile
+            puts "Arduino tarfile seems to have been downloaded already"
+          else
+            puts "Downloading Arduino binary with wget"
+            system("wget", "https://downloads.arduino.cc/#{tarfile}")
+          end
+
+          if File.exist? pkgname
+            puts "Tarfile seems to have been extracted already"
+          else
+            puts "Extracting archive with tar"
+            system("tar", "xf", tarfile)
+          end
+
+          if File.exist? force_install_location
+            puts "Arduino binary seems to have already been force-installed"
+          else
+            system("mv", pkgname, force_install_location)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/arduino_ci/ci_config.rb

@@ -0,0 +1,218 @@
+require 'yaml'
+
+# base config (platforms)
+#   project config - .arduino_ci_platforms.yml
+#     example config - .arduino_ci_plan.yml
+
+PACKAGE_SCHEMA = {
+  url: String
+}.freeze
+
+PLATFORM_SCHEMA = {
+  board: String,
+  package: String,
+  gcc: {
+    features: Array,
+    defines: Array,
+    warnings: Array,
+    flags: Array,
+  }
+}.freeze
+
+COMPILE_SCHEMA = {
+  platforms: Array,
+  libraries: Array,
+}.freeze
+
+UNITTEST_SCHEMA = {
+  platforms: Array,
+  libraries: Array,
+}.freeze
+module ArduinoCI
+
+  # The filename controlling (overriding) the defaults for testing.
+  # Files with this name can be used in the root directory of the Arduino library and in any/all of the example directories
+  CONFIG_FILENAME = ".arduino-ci.yaml".freeze
+
+  # Provide the configuration and CI plan
+  # - Read from a base config with default platforms defined
+  # - Allow project-specific overrides of platforms
+  # - Allow example-specific allowance of platforms to test
+  class CIConfig
+
+    class << self
+
+      # load the default set of platforms
+      # @return [ArudinoCI::CIConfig] The configuration with defaults filled in
+      def default
+        ret = new
+        ret.load_yaml(File.expand_path("../../../misc/default.yaml", __FILE__))
+        ret
+      end
+    end
+
+    attr_accessor :package_info
+    attr_accessor :platform_info
+    attr_accessor :compile_info
+    attr_accessor :unittest_info
+    def initialize
+      @package_info = {}
+      @platform_info = {}
+      @compile_info = {}
+      @unittest_info = {}
+    end
+
+    # Deep-clone a hash
+    # @param hash [Hash] the source data
+    # @return [Hash] a copy
+    def deep_clone(hash)
+      Marshal.load(Marshal.dump(hash))
+    end
+
+    # validate a data source according to a schema
+    # print out warnings for bad fields, and return only the good ones
+    # @param rootname [String] the name, for printing
+    # @param source [Hash] source data
+    # @param schema [Hash] a mapping of field names to their expected type
+    # @return [Hash] a copy, containing only expected & valid data
+    def validate_data(rootname, source, schema)
+      return nil if source.nil?
+      good_data = {}
+      source.each do |key, value|
+        ksym = key.to_sym
+        expected_type = schema[ksym].class == Class ? schema[ksym] : Hash
+        if !schema.include?(ksym)
+          puts "Warning: unknown field '#{ksym}' under definition for #{rootname}"
+        elsif value.nil?
+          # unspecificed, that's fine
+        elsif value.class != expected_type
+          puts "Warning: expected field '#{ksym}' of #{rootname} to be '#{expected_type}', got '#{value.class}'"
+        else
+          good_data[ksym] = value.class == Hash ? validate_data(key, value, schema[ksym]) : value
+        end
+      end
+      good_data
+    end
+
+    # Load configuration yaml from a file
+    # @param path [String] the source file
+    # @return [ArduinoCI::CIConfig] a reference to self
+    def load_yaml(path)
+      yml = YAML.load_file(path)
+      if yml.include?("packages")
+        yml["packages"].each do |k, v|
+          valid_data = validate_data("packages", v, PACKAGE_SCHEMA)
+          @package_info[k] = valid_data
+        end
+      end
+
+      if yml.include?("platforms")
+        yml["platforms"].each do |k, v|
+          valid_data = validate_data("platforms", v, PLATFORM_SCHEMA)
+          @platform_info[k] = valid_data
+        end
+      end
+
+      if yml.include?("compile")
+        valid_data = validate_data("compile", yml["compile"], COMPILE_SCHEMA)
+        @compile_info = valid_data
+      end
+
+      if yml.include?("unittest")
+        valid_data = validate_data("unittest", yml["unittest"], UNITTEST_SCHEMA)
+        @unittest_info = valid_data
+      end
+
+      self
+    end
+
+    # Override these settings with settings from another file
+    # @param path [String] the path to the settings yaml file
+    # @return [ArduinoCI::CIConfig] the new settings object
+    def with_override(path)
+      overridden_config = self.class.new
+      overridden_config.package_info  = deep_clone(@package_info)
+      overridden_config.platform_info = deep_clone(@platform_info)
+      overridden_config.compile_info  = deep_clone(@compile_info)
+      overridden_config.unittest_info = deep_clone(@unittest_info)
+      overridden_config.load_yaml(path)
+      overridden_config
+    end
+
+    # Try to override config with a file at a given location (if it exists)
+    # @param path [String] the path to the settings yaml file
+    # @return [ArduinoCI::CIConfig] the new settings object
+    def attempt_override(config_path)
+      return self unless File.exist? config_path
+      with_override(config_path)
+    end
+
+    # Produce a configuration, assuming the CI script runs from the working directory of the base project
+    # @return [ArduinoCI::CIConfig] the new settings object
+    def from_project_library
+      attempt_override(CONFIG_FILENAME)
+    end
+
+    # Produce a configuration override taken from an Arduino library example path
+    # handle either path to example file or example dir
+    # @param path [String] the path to the settings yaml file
+    # @return [ArduinoCI::CIConfig] the new settings object
+    def from_example(example_path)
+      base_dir = File.directory?(example_path) ? example_path : File.dirname(example_path)
+      attempt_override(File.join(base_dir, CONFIG_FILENAME))
+    end
+
+    # get information about a given platform: board name, package name, compiler stuff, etc
+    # @param platform_name [String] The name of the platform as defined in yaml
+    # @return [Hash] the settings object
+    def platform_definition(platform_name)
+      defn = @platform_info[platform_name]
+      return nil if defn.nil?
+      deep_clone(defn)
+    end
+
+    # the URL that gives the download info for a given package (a JSON file).
+    # this is NOT where the package comes from.
+    # @param package [String] the package name (e.g. "arduino:avr")
+    # @return [String] the URL defined for this package
+    def package_url(package)
+      return nil if @package_info[package].nil?
+      @package_info[package][:url]
+    end
+
+    # platforms to build [the examples on]
+    # @return [Array<String>] The platforms to build
+    def platforms_to_build
+      @compile_info[:platforms]
+    end
+
+    # platforms to unit test [the tests on]
+    # @return [Array<String>] The platforms to unit test on
+    def platforms_to_unittest
+      @unittest_info[:platforms]
+    end
+
+    # @return [Array<String>] The aux libraries required for building/verifying
+    def aux_libraries_for_build
+      return [] if @compile_info[:libraries].nil?
+      @compile_info[:libraries]
+    end
+
+    # @return [Array<String>] The aux libraries required for unit testing
+    def aux_libraries_for_unittest
+      return [] if @unittest_info[:libraries].nil?
+      @unittest_info[:libraries]
+    end
+
+    # get GCC configuration for a given platform
+    # @param platform_name [String] The name of the platform as defined in yaml
+    # @return [Hash] the settings
+    def gcc_config(platform_name)
+      plat = @platform_info[platform_name]
+      return {} if plat.nil?
+      return {} if plat[:gcc].nil?
+      plat[:gcc]
+    end
+  end
+
+end