arduino_ci 0.0.1 → 0.1.0

data/lib/arduino_ci/cpp_library.rb

@@ -0,0 +1,186 @@
+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
+
+    # 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)
+      real = File.realpath(some_dir)
+      Find.find(real).select { |path| CPP_EXTENSIONS.include?(File.extname(path)) }
+    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)
+      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
+      files = Find.find(@base_dir).select { |path| HPP_EXTENSIONS.include?(File.extname(path)) }
+      files.map { |path| File.dirname(path) }.uniq
+    end
+
+    # 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
+    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 = ["-o", executable] + test_args(aux_libraries, ci_gcc_config) + [test_file]
+      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)
+      Host.run(executable)
+    end
+
+  end
+
+end

data/lib/arduino_ci/display_manager.rb

@@ -0,0 +1,187 @@
+require 'arduino_ci/host'
+require 'singleton'
+require 'timeout'
+
+DESIRED_DISPLAY = ":1.0".freeze
+
+module ArduinoCI
+
+  # When arduino commands run, they need a graphical display.
+  # This class handles the setup of that display, if needed.
+  class DisplayManager
+    include Singleton
+
+    # @return [bool] whether the display manager is currently active
+    attr_reader :enabled
+
+    # @return [bool] whether to log messages to the terminal
+    attr_accessor :debug
+
+    def initialize
+      @existing = existing_display?
+      @enabled = false
+      @pid = nil
+      @debug = false
+
+      # pipes for input and output
+      @xv_pipe_out_wr = nil
+      @xv_pipe_err_wr = nil
+      @xv_pipe_out    = nil
+      @xv_pipe_err    = nil
+    end
+
+    # attempt to determine if the machine is running a graphical display (i.e. not Travis)
+    # @return [bool] whether there is already a GUI that can accept windows
+    def existing_display?
+      return true  if RUBY_PLATFORM.include? "darwin"
+      return false if ENV["DISPLAY"].nil?
+      return true  if ENV["DISPLAY"].include? ":"
+      false
+    end
+
+    # check whether a process is alive
+    # https://stackoverflow.com/a/32513298/2063546
+    # @param pid [Int] the process ID
+    # @return [bool]
+    def alive?(pid)
+      Process.kill(0, pid)
+      true
+    rescue
+      false
+    end
+
+    # check whether an X server is taking connections
+    # @param display [String] the display variable as it would be specified in the environment
+    # @return [bool]
+    def xserver_exist?(display)
+      system({ "DISPLAY" => display }, "xdpyinfo", out: File::NULL, err: File::NULL)
+    end
+
+    # wait for the xvfb command to launch
+    # @param display [String] the value of the DISPLAY env var
+    # @param pid [Int] the process of Xvfb
+    # @param timeout [Int] the timeout in seconds
+    # @return [Bool] whether we detected a launch
+    def xvfb_launched?(display, pid, timeout)
+      Timeout.timeout(timeout) do
+        loop do
+          unless alive? pid
+            puts "Xvfb process has died"
+            return false
+          end
+          x = xserver_exist? display
+          puts "xdpyinfo reports X server status as #{x}" if debug
+          return true if x
+          sleep(0.1)
+        end
+      end
+    rescue Timeout::Error
+      false
+    end
+
+    # enable a virtual display
+    def enable
+      if @existing
+        puts "DisplayManager enable: no-op for what appears to be an existing display" if debug
+        @enabled = true
+        return
+      end
+
+      return unless @pid.nil?  # TODO: disable first?
+      @xv_pipe_out.close unless @xv_pipe_out.nil?
+      @xv_pipe_err.close unless @xv_pipe_err.nil?
+
+      # open Xvfb
+      xvfb_cmd = [
+        "Xvfb",
+        "+extension", "RANDR",
+        ":1",
+        "-ac",
+        "-screen", "0",
+        "1280x1024x16",
+      ]
+      puts "Xvfb launching" if debug
+
+      @xv_pipe_out, @xv_pipe_out_wr = IO.pipe
+      @xv_pipe_err, @xv_pipe_err_wr = IO.pipe
+      pipe = IO.popen(xvfb_cmd, stdout: @xv_pipe_out_wr, err: @xv_pipe_err_wr)
+      @pid = pipe.pid
+      @enabled = xvfb_launched?(DESIRED_DISPLAY, @pid, 30)
+    end
+
+    # disable the virtual display
+    def disable
+      if @existing
+        puts "DisplayManager disable: no-op for what appears to be an existing display" if debug
+        return @enabled = false
+      end
+
+      return @enabled = false if @pid.nil?
+
+      # https://www.whatastruggle.com/timeout-a-subprocess-in-ruby
+      begin
+        Timeout.timeout(30) do
+          Process.kill("TERM", @pid)
+          puts "Xvfb TERMed" if debug
+        end
+      rescue Timeout::Error
+        Process.kill(9, @pid)
+        puts "Xvfb KILLed" if debug
+      ensure
+        Process.wait @pid
+        @enabled = false
+        @pid = nil
+
+        @xv_pipe_out_wr.close
+        @xv_pipe_err_wr.close
+      end
+    end
+
+    # Enable a virtual display for the duration of the given block
+    # @yield [environment] The code to execute within the display environment
+    # @yieldparam [Hash] the environment variables relating to the display
+    def with_display
+      was_enabled = @enabled
+      enable unless was_enabled
+      begin
+        yield environment
+      ensure
+        disable unless was_enabled
+      end
+    end
+
+    # run a command in a display
+    # @return [bool]
+    def run(*args, **kwargs)
+      ret = false
+      # do some work to extract & merge environment variables if they exist
+      has_env = !args.empty? && args[0].class == Hash
+      with_display do |env_vars|
+        env_vars = {} if env_vars.nil?
+        env_vars.merge!(args[0]) if has_env
+        actual_args = has_env ? args[1..-1] : args  # need to shift over if we extracted args
+        full_cmd = env_vars.empty? ? actual_args : [env_vars] + actual_args
+        ret = Host.run(*full_cmd, **kwargs)
+      end
+      ret
+    end
+
+    # run a command in a display with no output
+    # @return [bool]
+    def run_silent(*args)
+      run(*args, out: File::NULL, err: File::NULL)
+    end
+
+    # @return [Hash] the environment variables for the display
+    def environment
+      return nil unless @existing || @enabled
+      return { "EXISTING_DISPLAY" => "YES" } if @existing
+      { "DISPLAY" => DESIRED_DISPLAY }
+    end
+
+    # On finalize, ensure child process is ended
+    def self.finalize
+      disable
+    end
+  end
+end

data/lib/arduino_ci/host.rb

@@ -0,0 +1,36 @@
+require 'os'
+
+module ArduinoCI
+
+  # Tools for interacting with the host machine
+  class Host
+    # Cross-platform way of finding an executable in the $PATH.
+    # via https://stackoverflow.com/a/5471032/2063546
+    #   which('ruby') #=> /usr/bin/ruby
+    # @param cmd [String] the command to search for
+    # @return [String] the full path to the command if it exists
+    def self.which(cmd)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+      end
+      nil
+    end
+
+    # run a command in a display
+    def self.run(*args, **kwargs)
+      system(*args, **kwargs)
+    end
+
+    # return [Symbol] the operating system of the host
+    def self.os
+      return :osx if OS.osx?
+      return :linux if OS.linux?
+      return :windows if OS.windows?
+    end
+
+  end
+end

data/lib/arduino_ci/version.rb

@@ -1,3 +1,3 @@
 module ArduinoCI
-  VERSION = "0.0.1".freeze
+  VERSION = "0.1.0".freeze
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: arduino_ci
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Ian Katz
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-10 00:00:00.000000000 Z
+date: 2018-01-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: os
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -44,50 +58,49 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.46.0
+        version: 0.49.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.46.0
+        version: 0.49.0
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.9.11
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.9.11
 description: ''
 email:
 - ifreecarve@gmail.com
-executables: []
+executables:
+- arduino_ci_remote.rb
 extensions: []
 extra_rdoc_files: []
 files:
 - ".yardopts"
 - README.md
+- exe/arduino_ci_remote.rb
 - lib/arduino_ci.rb
+- lib/arduino_ci/arduino_cmd.rb
+- lib/arduino_ci/arduino_cmd_linux.rb
+- lib/arduino_ci/arduino_cmd_linux_builder.rb
+- lib/arduino_ci/arduino_cmd_osx.rb
+- lib/arduino_ci/arduino_installation.rb
+- lib/arduino_ci/ci_config.rb
+- lib/arduino_ci/cpp_library.rb
+- lib/arduino_ci/display_manager.rb
+- lib/arduino_ci/host.rb
 - lib/arduino_ci/version.rb
 homepage: http://github.com/ifreecarve/arduino_ci
 licenses: