luffa 1.0.0

data/lib/luffa/ios/simulator.rb

@@ -0,0 +1,36 @@
+require 'singleton'
+
+module Luffa
+  class Simulator
+    def core_simulator_home_dir
+      @core_simulator_home_dir ||= File.expand_path('~/Library/Developer/CoreSimulator')
+    end
+
+    def core_simulator_device_dir(sim_udid=nil)
+      if sim_udid.nil?
+        @core_simulator_device_dir ||= File.expand_path(File.join(core_simulator_home_dir, 'Devices'))
+      else
+        File.expand_path(File.join(core_simulator_device_dir, sim_udid))
+      end
+    end
+
+    def core_simulator_device_containers_dir(sim_udid)
+      File.expand_path(File.join(core_simulator_device_dir(sim_udid), 'Containers'))
+    end
+
+    def core_simulator_for_xcode_version(idiom, form_factor, xcode_version)
+      if xcode_version < Luffa::Version.new('6.1')
+        ios_version = '8.0'
+      elsif xcode_version < Luffa::Version.new('6.2')
+        ios_version = '8.1'
+      elsif xcode_version < Luffa::Version.new('6.3')
+        ios_version = '8.2'
+      elsif xcode_version >= Luffa::Version.new('6.3')
+        ios_version = '8.3'
+      else
+        raise "Unsupported Xcode version: #{xcode_version}"
+      end
+      "#{idiom} #{form_factor} (#{ios_version} Simulator)"
+    end
+  end
+end

data/lib/luffa/ios/xcode.rb

@@ -0,0 +1,93 @@
+module Luffa
+  class XcodeInstall
+    attr :version
+    attr :path
+
+    def initialize(path)
+      Luffa::Xcode.with_developer_dir(path) do
+        @version = lambda {
+          xcode_build_output = `xcrun xcodebuild -version`.split(/\s/)[1]
+          Luffa::Version.new(xcode_build_output)
+        }.call
+
+        @path = path
+      end
+    end
+
+    def version_string
+      version.to_s
+    end
+
+    def == (other)
+      other.path == path && other.version == version
+    end
+  end
+
+  class Xcode
+
+    def self.with_developer_dir(developer_dir, &block)
+      original_developer_dir = Luffa::Environment.developer_dir
+      stripped = developer_dir.strip
+      begin
+        ENV['DEVELOPER_DIR'] = stripped
+        block.call
+      ensure
+        ENV['DEVELOPER_DIR'] = original_developer_dir
+      end
+    end
+
+    def self.with_xcode_install(xcode_install, &block)
+      self.with_developer_dir(xcode_install.path, &block)
+    end
+
+    def self.ios_version_incompatible_with_xcode_version?(ios_version, xcode_version)
+      [(ios_version >= Luffa::Version.new('8.0') && xcode_version < Luffa::Version.new('6.0')),
+       (ios_version >= Luffa::Version.new('8.1') && xcode_version < Luffa::Version.new('6.1')),
+       (ios_version >= Luffa::Version.new('8.2') && xcode_version < Luffa::Version.new('6.2')),
+       (ios_version >= Luffa::Version.new('8.3') && xcode_version < Luffa::Version.new('6.3'))].any?
+    end
+
+    def xcode_installs
+      @xcode_installs ||= lambda do
+        min_xcode_version = Luffa::Version.new('5.1.1')
+        active_xcode = Luffa::Xcode.new.active_xcode
+        xcodes = [active_xcode]
+        Dir.glob('/Xcode/*/*.app/Contents/Developer').each do |path|
+          xcode_version = path[/(\d\.\d(\.\d)?)/, 0]
+          if Luffa::Version.new(xcode_version) >= min_xcode_version
+            install = Luffa::XcodeInstall.new(path)
+            unless install == active_xcode
+              xcodes << install
+            end
+          end
+        end
+        xcodes
+      end.call
+    end
+
+    # The developer dir at the time the tests start.
+    #
+    # To change the active Xcode:
+    #
+    #   $ DEVELOPER_DIR=/path/to/Xcode.app/Contents/Developer be rake spec
+    def active_xcode_dir
+      @active_xcode_dir ||= lambda {
+        env = Luffa::Environment.developer_dir
+        if env
+          env
+        else
+          # fall back to xcode-select
+          xcode_select_path
+        end
+      }.call
+    end
+
+    def xcode_select_path
+      @xcode_select_dir ||= `xcode-select --print-path`.strip
+    end
+
+    def active_xcode
+      @active_xcode ||= Luffa::XcodeInstall.new(active_xcode_dir)
+    end
+  end
+end

data/lib/luffa/logging.rb

@@ -0,0 +1,21 @@
+module Luffa
+  def self.log_unix_cmd(msg)
+    puts "\033[36mEXEC: #{msg}\033[0m" if msg
+  end
+
+  def self.log_pass(msg)
+    puts "\033[32mPASS: #{msg}\033[0m" if msg
+  end
+
+  def self.log_warn(msg)
+    puts "\033[34mWARN: #{msg}\033[0m"
+  end
+
+  def self.log_fail(msg)
+    puts "\033[31mFAIL: #{msg}\033[0m" if msg
+  end
+
+  def self.log_info(msg)
+    puts "\033[46mINFO: #{msg}\033[0m" if msg
+  end
+end

data/lib/luffa/patches/awesome_print.rb

@@ -0,0 +1,16 @@
+require 'awesome_print'
+
+# monkey patch for AwesomePrint + objects that implement '=='
+module AwesomePrint
+  class Formatter
+    def awesome_self(object, type)
+      if @options[:raw] && object.instance_variables.any?
+        awesome_object(object)
+      elsif object.respond_to?(:to_hash)
+        awesome_hash(object.to_hash)
+      else
+        colorize(object.inspect.to_s, type)
+      end
+    end
+  end
+end

data/lib/luffa/patches/kernel.rb

@@ -0,0 +1,19 @@
+module Kernel
+  def capture_stdout
+    out = StringIO.new
+    $stdout = out
+    yield
+    return out
+  ensure
+    $stdout = STDOUT
+  end
+
+  def capture_stderr
+    out = StringIO.new
+    $stderr = out
+    yield
+    return out
+  ensure
+    $stderr = STDERR
+  end
+end

data/lib/luffa/retry.rb

@@ -0,0 +1,13 @@
+require 'singleton'
+
+module Luffa
+  class Retry
+    include Singleton
+
+    def launch_retries
+      @launch_retries ||= lambda {
+        Luffa::Environment.travis_ci? ? 8 : 2
+      }.call
+    end
+  end
+end

data/lib/luffa/unix_command.rb

@@ -0,0 +1,43 @@
+module Luffa
+  def self.unix_command(cmd, opts={})
+    default_opts = {:pass_msg => nil,
+                    :fail_msg => nil,
+                    :exit_on_nonzero_status => true,
+                    :env_vars => {},
+                    :log_cmd => true,
+                    :obscure_fields => []}
+    merged_opts = default_opts.merge(opts)
+
+    obscure_fields = merged_opts[:obscure_fields]
+
+    if not obscure_fields.empty? and merged_opts[:log_cmd]
+      obscured = cmd.split(' ').map do |token|
+        if obscure_fields.include? token
+          "#{token[0,1]}***#{token[token.length-1,1]}"
+        else
+          token
+        end
+      end
+      Luffa.log_unix_cmd obscured.join(' ')
+    elsif merged_opts[:log_cmd]
+      Luffa.log_unix_cmd cmd
+    end
+
+    exit_on_err = merged_opts[:exit_on_nonzero_status]
+    unless exit_on_err
+      system 'set +e'
+    end
+
+    env_vars = merged_opts[:env_vars]
+    res = system(env_vars, cmd)
+    exit_code = $?.exitstatus
+    if res
+      Luffa.log_pass merged_opts[:pass_msg]
+    else
+      Luffa.log_fail merged_opts[:fail_msg]
+      exit exit_code if exit_on_err
+    end
+    system 'set -e'
+    exit_code
+  end
+end

data/lib/luffa/version.rb

@@ -0,0 +1,166 @@
+module Luffa
+  VERSION = '1.0.0'
+
+  # 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_release => nil
+    #
+    # @example
+    #  version = Version.new(1.6.3.pre5)
+    #  version.major       => 1
+    #  version.minor       => 6
+    #  version.patch       => 3
+    #  version.pre         => true
+    #  version.pre_release => 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
+
+    # 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/luffa/with_debugging.rb

@@ -0,0 +1,13 @@
+module Luffa
+  module Debug
+    def self.with_debugging(&block)
+      original_value = ENV['DEBUG']
+      ENV['DEBUG'] = '1'
+      begin
+        block.call
+      ensure
+        ENV['DEBUG'] = original_value
+      end
+    end
+  end
+end

data/script/ci/com.apple.dt.instruments.process.analysis.plist

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>allow-root</key>
+	<true/>
+	<key>authenticate-user</key>
+	<true/>
+	<key>class</key>
+	<string>user</string>
+	<key>comment</key>
+	<string>Rights for Instruments</string>
+	<key>created</key>
+	<real>409022991.255041</real>
+	<key>group</key>
+	<string>admin</string>
+	<key>identifier</key>
+	<string>com.apple.dt.instruments.dtsecurity.xpc</string>
+	<key>modified</key>
+	<real>409022991.255041</real>
+	<key>requirement</key>
+	<string>identifier "com.apple.dt.instruments.dtsecurity.xpc" and anchor apple</string>
+	<key>session-owner</key>
+	<false/>
+	<key>shared</key>
+	<true/>
+	<key>timeout</key>
+	<integer>36000</integer>
+	<key>tries</key>
+	<integer>10000</integer>
+	<key>version</key>
+	<integer>0</integer>
+</dict>
+</plist>