run_loop_tcc 2.1.3

data/lib/run_loop/version.rb

@@ -0,0 +1,182 @@
+module RunLoop
+  VERSION = "2.1.3"
+
+  # A model of a software release version that can be used to compare two versions.
+  #
+  # Calabash and RunLoop try very hard to comply with Semantic Versioning rules.
+  # However, the semantic versioning spec is incompatible with RubyGem's patterns
+  # for pre-release gems.
+  #
+  # > "But returning to the practical: No release version of SemVer is compatible with Rubygems." - _David Kellum_
+  #
+  # Calabash and RunLoop version numbers will be in the form `<major>.<minor>.<patch>[.pre<N>]`.
+  #
+  # @see http://semver.org/
+  # @see http://gravitext.com/2012/07/22/versioning.html
+  class Version
+
+    # @!attribute [rw] major
+    #   @return [Integer] the major version
+    attr_accessor :major
+
+    # @!attribute [rw] minor
+    #   @return [Integer] the minor version
+    attr_accessor :minor
+
+    # @!attribute [rw] patch
+    #   @return [Integer] the patch version
+    attr_accessor :patch
+
+    # @!attribute [rw] pre
+    #   @return [Boolean] true if this is a pre-release version
+    attr_accessor :pre
+
+    # @!attribute [rw] pre_version
+    #   @return [Integer] if this is a pre-release version, returns the
+    #     pre-release version; otherwise this is nil
+    attr_accessor :pre_version
+
+    # Creates a new Version instance with all the attributes set.
+    #
+    # @example
+    #  version = Version.new(0.10.1)
+    #  version.major       => 0
+    #  version.minor       => 10
+    #  version.patch       => 1
+    #  version.pre         => false
+    #  version.pre_version => nil
+    #
+    # @example
+    #  version = Version.new(1.6.3.pre5)
+    #  version.major       => 1
+    #  version.minor       => 6
+    #  version.patch       => 3
+    #  version.pre         => true
+    #  version.pre_version => 5
+    #
+    # @param [String] version the version string to parse.
+    # @raise [ArgumentError] if version is not in the form 5, 6.1, 7.1.2, 8.2.3.pre1
+    def initialize(version)
+      tokens = version.strip.split('.')
+      count = tokens.count
+      if tokens.empty?
+        raise ArgumentError, "expected '#{version}' to be like 5, 6.1, 7.1.2, 8.2.3.pre1"
+      end
+
+      if count < 4 and tokens.any? { |elm| elm =~ /\D/ }
+        raise ArgumentError, "expected '#{version}' to be like 5, 6.1, 7.1.2, 8.2.3.pre1"
+      end
+
+      if count == 4
+        @pre = tokens[3]
+        pre_tokens = @pre.scan(/\D+|\d+/)
+        @pre_version = pre_tokens[1].to_i if pre_tokens.count == 2
+      end
+
+      @major, @minor, @patch = version.split('.').map(&:to_i)
+    end
+
+    # Returns an string representation of this version.
+    # @return [String] a string in the form `<major>.<minor>.<patch>[.pre<N>]`
+    def to_s
+      str = [major, minor, patch].compact.join('.')
+      str = "#{str}.#{pre}" if pre
+      str
+    end
+
+    def inspect
+      "#<Version #{to_s}>"
+    end
+
+    # Compare this version to another for _object_ equality.  This allows
+    # Version instances to be used as Hash keys.
+    # @param [Version] other the version to compare against.
+    def eql?(other)
+      hash == other.hash
+    end
+
+    # The hash method for this instance.
+    def hash
+      to_s.hash
+    end
+
+    # Compare this version to another for equality.
+    # @param [Version] other the version to compare against
+    # @return [Boolean] true if this Version is the same as `other`
+    def == (other)
+      Version.compare(self, other) == 0
+    end
+
+    # Compare this version to another for inequality.
+    # @param [Version] other the version to compare against
+    # @return [Boolean] true if this Version is not the same as `other`
+    def != (other)
+      Version.compare(self, other) != 0
+    end
+
+    # Is this version less-than another version?
+    # @param [Version] other the version to compare against
+    # @return [Boolean] true if this Version is less-than `other`
+    def < (other)
+      Version.compare(self, other) < 0
+    end
+
+    # Is this version greater-than another version?
+    # @param [Version] other the version to compare against
+    # @return [Boolean] true if this Version is greater-than `other`
+    def > (other)
+      Version.compare(self, other) > 0
+    end
+
+    # Is this version less-than or equal to another version?
+    # @param [Version] other the version to compare against
+    # @return [Boolean] true if this Version is less-than or equal `other`
+    def <= (other)
+      Version.compare(self, other) <= 0
+    end
+
+    # Is this version greater-than or equal to another version?
+    # @param [Version] other the version to compare against
+    # @return [Boolean] true if this Version is greater-than or equal `other`
+    def >= (other)
+      Version.compare(self, other) >= 0
+    end
+
+    # Compare version `a` to version `b`.
+    #
+    # @example
+    #   compare Version.new(0.10.0), Version.new(0.9.0)  =>  1
+    #   compare Version.new(0.9.0),  Version.new(0.10.0) => -1
+    #   compare Version.new(0.9.0),  Version.new(0.9.0)  =>  0
+    #
+    # @return [Integer] an integer `(-1, 1)`
+    def self.compare(a, b)
+
+      if a.major != b.major
+        return a.major > b.major ? 1 : -1
+      end
+
+      if a.minor != b.minor
+        return a.minor.to_i  > b.minor.to_i ? 1 : -1
+      end
+
+      if a.patch != b.patch
+        return a.patch.to_i > b.patch.to_i ? 1 : -1
+      end
+
+      return -1 if a.pre and (not a.pre_version) and b.pre_version
+      return 1 if a.pre_version and b.pre and (not b.pre_version)
+
+      return -1 if a.pre and (not b.pre)
+      return 1 if (not a.pre) and b.pre
+
+      return -1 if a.pre_version and (not b.pre_version)
+      return 1 if (not a.pre_version) and b.pre_version
+
+      if a.pre_version != b.pre_version
+        return a.pre_version.to_i > b.pre_version.to_i ? 1 : -1
+      end
+      0
+    end
+  end
+end

data/lib/run_loop/xcode.rb

@@ -0,0 +1,318 @@
+require 'open3'
+
+module RunLoop
+
+  # A model of the active Xcode version.
+  #
+  # @note All command line tools are run in the context of `xcrun`.
+  #
+  # Throughout this class's documentation, there are references to the
+  # _active version of Xcode_.  The active Xcode version is the one returned
+  # by `xcrun xcodebuild`.  The current Xcode version can be set using
+  # `xcode-select` or overridden using the `DEVELOPER_DIR`.
+  class Xcode
+
+    include RunLoop::Regex
+
+    # Returns a String representation.
+    def to_s
+      "#<Xcode #{version.to_s}>"
+    end
+
+    # Returns debug String representation
+    def inspect
+      to_s
+    end
+
+    # Returns a version instance for `Xcode 8.0`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 8.0
+    def v80
+      fetch_version(:v80)
+    end
+
+    # Returns a version instance for `Xcode 7.3`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 7.3
+    def v73
+      fetch_version(:v73)
+    end
+
+    # Returns a version instance for `Xcode 7.2`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 7.2
+    def v72
+      fetch_version(:v72)
+    end
+
+    # Returns a version instance for `Xcode 7.1`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 7.1
+    def v71
+      fetch_version(:v71)
+    end
+
+    # Returns a version instance for `Xcode 7.0`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 7.0
+    def v70
+      fetch_version(:v70)
+    end
+
+    # Returns a version instance for `Xcode 6.4`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 6.4
+    def v64
+      fetch_version(:v64)
+    end
+
+    # Returns a version instance for `Xcode 6.3`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 6.3
+    def v63
+      fetch_version(:v63)
+    end
+
+    # Returns a version instance for `Xcode 6.2`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 6.2
+    def v62
+      fetch_version(:v62)
+    end
+
+    # Returns a version instance for `Xcode 6.1`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 6.1
+    def v61
+      fetch_version(:v61)
+    end
+
+    # Returns a version instance for `Xcode 6.0`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 6.0
+    def v60
+      fetch_version(:v60)
+    end
+
+    # Returns a version instance for `Xcode 5.1`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 5.1
+    def v51
+      fetch_version(:v51)
+    end
+
+    # Returns a version instance for `Xcode 5.0`; used to check for the
+    # availability of features and paths to various items on the filesystem.
+    #
+    # @return [RunLoop::Version] 5.0
+    def v50
+      fetch_version(:v50)
+    end
+
+    # Is the active Xcode version 8.0 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 8.0
+    def version_gte_8?
+      version >= v80
+    end
+
+    # Is the active Xcode version 7.3 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 7.3
+    def version_gte_73?
+      version >= v73
+    end
+
+    # Is the active Xcode version 7.2 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 7.2
+    def version_gte_72?
+      version >= v72
+    end
+
+    # Is the active Xcode version 7.1 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 7.1
+    def version_gte_71?
+      version >= v71
+    end
+
+    # Is the active Xcode version 7 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 7.0
+    def version_gte_7?
+      version >= v70
+    end
+
+    # Is the active Xcode version 6.4 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 6.4
+    def version_gte_64?
+      version >= v64
+    end
+
+    # Is the active Xcode version 6.3 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 6.3
+    def version_gte_63?
+      version >= v63
+    end
+
+    # Is the active Xcode version 6.2 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 6.2
+    def version_gte_62?
+      version >= v62
+    end
+
+    # Is the active Xcode version 6.1 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 6.1
+    def version_gte_61?
+      version >= v61
+    end
+
+    # Is the active Xcode version 6 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 6.0
+    def version_gte_6?
+      version >= v60
+    end
+
+    # @deprecated 2.1.0
+    # Is the active Xcode version 5.1 or above?
+    #
+    # @return [Boolean] `true` if the current Xcode version is >= 5.1
+    def version_gte_51?
+      #RunLoop.deprecated("2.1.0", "No replacement")
+      version >= v51
+    end
+
+    # Returns the current version of Xcode.
+    #
+    # @return [RunLoop::Version] The current version of Xcode as reported by
+    #  `xcrun xcodebuild -version`.
+    def version
+      @xcode_version ||= lambda do
+        execute_command(['-version']) do |stdout, _, _|
+          version_string = stdout.read.chomp[VERSION_REGEX, 0]
+          RunLoop::Version.new(version_string)
+        end
+      end.call
+    end
+
+    # Is this a beta version of Xcode?
+    #
+    # @note Relies on Xcode beta versions having and app bundle named Xcode-Beta.app
+    # @return [Boolean] True if the Xcode version is beta.
+    def beta?
+      developer_dir[/Xcode-[Bb]eta.app/, 0]
+    end
+
+    # Returns the path to the current developer directory.
+    #
+    # From the man pages:
+    #
+    # ```
+    # $ man xcode-select
+    # DEVELOPER_DIR
+    # Overrides the active developer directory. When DEVELOPER_DIR is set,
+    # its value will be used instead of the system-wide active developer
+    # directory.
+    #```
+    #
+    # @return [String] path to current developer directory
+    #
+    # @raise [RuntimeError] If path to Xcode.app/Contents/Developer
+    #   cannot be determined.
+    def developer_dir
+      @xcode_developer_dir ||= lambda do
+        if RunLoop::Environment.developer_dir
+          path = RunLoop::Environment.developer_dir
+        else
+          path = xcode_select_path
+        end
+
+        if !File.directory?(path)
+          raise RuntimeError,
+%Q{Cannot determine the active Xcode.  Expected an Xcode here:
+
+#{path}
+
+Check the value of xcode-select:
+
+# Does this resolve to a valid Xcode.app/Contents/Developer path?
+$ xcode-select --print-path
+
+Is the DEVELOPER_DIR variable set in your environment?  You would
+only use this if you have multiple Xcode's installed.
+
+$ echo $DEVELOPER_DIR
+
+See the man pages for xcrun and xcode-select for details.
+
+$ man xcrun
+$ man xcode-select
+}
+        end
+        path
+      end.call
+    end
+
+    private
+
+    attr_reader :xcode_versions
+
+    def xcode_versions
+      @xcode_versions ||= {}
+    end
+
+    def fetch_version(key)
+      ensure_valid_version_key key
+      value = xcode_versions[key]
+
+      return value if value
+
+      string = key.to_s
+      string[0] = ''
+      version_string = string.split(/(?!^)/).join('.')
+      version = RunLoop::Version.new(version_string)
+      xcode_versions[key] = version
+      version
+    end
+
+    def ensure_valid_version_key(key)
+      string = key.to_s
+      if string.length != 3
+        raise "Expected version key '#{key}' to have exactly 3 characters"
+      end
+
+      unless string[/v\d{2}/, 0]
+        raise "Expected version key '#{key}' to match vXX pattern"
+      end
+    end
+
+    def execute_command(args)
+      Open3.popen3('xcrun', 'xcodebuild', *args) do |_, stdout, stderr, wait_thr|
+        yield stdout, stderr, wait_thr
+      end
+    end
+
+    def xcode_select_path
+      Open3.popen3('xcode-select', '--print-path') do |_, stdout, _, _|
+        stdout.read.chomp
+      end
+    end
+  end
+end

data/lib/run_loop/xcrun.rb

@@ -0,0 +1,107 @@
+module RunLoop
+  class Xcrun
+
+    require "command_runner"
+    require "run_loop/encoding"
+    include RunLoop::Encoding
+
+    # Controls the behavior of Xcrun#run_command_in_context.
+    #
+    # You can override these values if they do not work in your environment.
+    #
+    # For cucumber users, the best place to override would be in your
+    # features/support/env.rb.
+    #
+    # For example:
+    #
+    # RunLoop::Xcrun::DEFAULT_OPTIONS[:timeout] = 60
+    DEFAULT_OPTIONS = {
+      :timeout => 30,
+      :log_cmd => false
+    }
+
+    # Raised when Xcrun fails.
+    class Error < RuntimeError; end
+
+    # Raised when Xcrun times out.
+    class TimeoutError < RuntimeError; end
+
+    # Aliased to #exec, which will be removed in 3.0
+    def run_command_in_context(args, options={})
+      merged_options = DEFAULT_OPTIONS.merge(options)
+
+      timeout = merged_options[:timeout]
+
+      unless args.is_a?(Array)
+        raise ArgumentError,
+              "Expected args '#{args}' to be an Array, but found '#{args.class}'"
+      end
+
+      args.each do |arg|
+        unless arg.is_a?(String)
+          raise ArgumentError,
+%Q{Expected arg '#{arg}' to be a String, but found '#{arg.class}'
+IO.popen requires all arguments to be Strings.
+}
+        end
+      end
+
+      cmd = "xcrun #{args.join(' ')}"
+
+      # Don't see your log?
+      # Commands are only logged when debugging.
+      RunLoop.log_unix_cmd(cmd) if merged_options[:log_cmd]
+
+      hash = {}
+
+      begin
+
+        start_time = Time.now
+        command_output = CommandRunner.run(['xcrun'] + args, timeout: timeout)
+
+        out = ensure_command_output_utf8(command_output[:out], cmd)
+        process_status = command_output[:status]
+
+        hash =
+              {
+                    :out => out,
+                    :pid => process_status.pid,
+                    # nil if process was killed before completion
+                    :exit_status => process_status.exitstatus
+              }
+
+      rescue RunLoop::Encoding::UTF8Error => e
+        raise e
+      rescue => e
+        elapsed = "%0.2f" % (Time.now - start_time)
+        raise Error,
+%Q{Xcrun encountered an error after #{elapsed} seconds:
+
+#{e}
+
+executing this command:
+
+#{cmd}
+}
+      end
+
+      if hash[:exit_status].nil?
+        elapsed = "%0.2f" % (Time.now - start_time)
+        raise TimeoutError,
+%Q{Xcrun timed out after #{elapsed} seconds executing
+
+#{cmd}
+
+with a timeout of #{timeout}
+}
+      end
+
+      hash
+    end
+
+    # TODO Remove in 3.0
+    # https://github.com/calabash/run_loop/issues/478
+    alias_method :exec, :run_command_in_context
+  end
+end
+