run_loop_tcc 2.1.3

data/lib/run_loop/detect_aut/detect.rb

@@ -0,0 +1,185 @@
+module RunLoop
+
+  # @!visibility private
+  module DetectAUT
+
+    # @!visibility private
+    def self.detect_app_under_test(options)
+      app = self.detect_app(options)
+      if app.is_a?(RunLoop::App) || app.is_a?(RunLoop::Ipa)
+        {
+          :app => app,
+          :bundle_id => app.bundle_identifier,
+          :is_ipa => app.is_a?(RunLoop::Ipa)
+        }
+      else
+        {
+          :app => nil,
+          :bundle_id => app,
+          :is_ipa => false
+        }
+      end
+    end
+
+    # @!visibility private
+    class Detect
+      include RunLoop::DetectAUT::Errors
+      include RunLoop::DetectAUT::XamarinStudio
+      include RunLoop::DetectAUT::Xcode
+
+      # @!visibility private
+      DEFAULTS = {
+        :search_depth => 10
+      }
+
+      # @!visibility private
+      def app_for_simulator
+        path = RunLoop::Environment.path_to_app_bundle
+        return RunLoop::App.new(path) if path
+
+        if xcode_project?
+          apps, search_dirs = detect_xcode_apps
+        elsif xamarin_project?
+          search_dirs = [solution_directory]
+          apps = candidate_apps(search_dirs.first)
+        else
+          search_dirs = [Dir.pwd]
+          apps = candidate_apps(search_dirs.first)
+        end
+
+        if apps.empty?
+          raise_no_simulator_app_found(search_dirs, DEFAULTS[:search_depth])
+        end
+
+        app = select_most_recent_app(apps)
+
+        RunLoop.log_info2("Detected app at path:")
+        RunLoop.log_info2("#{app.path}")
+        time_str = mtime(app).strftime("%a %d %b %Y %H:%M:%S %Z")
+        RunLoop.log_info2("Modification time of app: #{time_str}")
+        RunLoop.log_info2("If this is incorrect, set the APP variable and/or rebuild your app")
+        RunLoop.log_info2("It is your responsibility to ensure you are testing the right app.")
+
+        app
+      end
+
+      # @!visibility private
+      # @param [Array<RunLoop::Detect>] apps
+      def select_most_recent_app(apps)
+        apps.max do |a, b|
+          mtime(a).to_i <=> mtime(b).to_i
+        end
+      end
+
+      # @!visibility private
+      # @param [String] bundle_path
+      def app_with_bundle(bundle_path)
+        RunLoop::App.new(bundle_path)
+      end
+
+      # @!visibility private
+      # @param [String] base_dir where to start the recursive search
+      def candidate_apps(base_dir)
+        candidates = []
+
+        globs = globs_for_app_search(base_dir)
+        Dir.glob(globs).each do |bundle_path|
+          # Gems, like run-loop, can contain *.app if the user is building
+          # from :git =>, :github =>, or :path => sources.
+          next if bundle_path[/vendor\/cache/, 0] != nil
+          app = app_or_nil(bundle_path)
+          candidates << app if app
+        end
+        candidates
+      end
+
+      # @!visibility private
+      # @param [String] bundle_path path to .app
+      def app_or_nil(bundle_path)
+        return nil if !RunLoop::App.valid?(bundle_path)
+
+        app = app_with_bundle(bundle_path)
+        if app.simulator? && app.calabash_server_version
+          app
+        else
+          nil
+        end
+      end
+
+      # @!visibility private
+      # @param [RunLoop::Detect] app
+      def mtime(app)
+        path = File.join(app.path, app.executable_name)
+        File.mtime(path)
+      end
+
+      # @!visibility private
+      def globs_for_app_search(base_dir)
+        search_depth = DEFAULTS[:search_depth]
+        Array.new(search_depth) do |depth|
+          File.join(base_dir, *Array.new(depth) { |_| "*"}, "*.app")
+        end
+      end
+    end
+
+    private
+
+    # @!visibility private
+    def self.app_from_options(options)
+      options[:app] || options[:bundle_id]
+    end
+
+    # @!visibility private
+    def self.app_from_environment
+      app_bundle_path = RunLoop::Environment.path_to_app_bundle
+
+      candidate = app_bundle_path
+      if app_bundle_path && !File.exist?(app_bundle_path)
+        candidate = File.basename(app_bundle_path)
+      end
+
+      candidate || RunLoop::Environment.bundle_id
+    end
+
+    # @!visibility private
+    def self.app_from_constant
+      (defined?(APP_BUNDLE_PATH) && APP_BUNDLE_PATH) ||
+        (defined?(APP) && APP)
+    end
+
+    # @!visibility private
+    def self.app_from_opts_or_env_or_constant(options)
+       self.app_from_options(options) ||
+         self.app_from_environment ||
+         self.app_from_constant
+    end
+
+    # @!visibility private
+    def self.detector
+      RunLoop::DetectAUT::Detect.new
+    end
+
+    # @!visibility private
+    def self.detect_app(options)
+      app = self.app_from_opts_or_env_or_constant(options)
+
+      # Options or constant defined an instance of App or Ipa
+      return app if app && (app.is_a?(RunLoop::App) || app.is_a?(RunLoop::Ipa))
+
+      # User provided no information, so we attempt to auto detect
+      if app.nil? || app == ""
+        return self.detector.app_for_simulator
+      end
+
+      extension = File.extname(app)
+      if extension == ".ipa" && File.exist?(app)
+        RunLoop::Ipa.new(app)
+      elsif extension == ".app" && File.exist?(app)
+        RunLoop::App.new(app)
+      else
+        # Probably a bundle identifier.
+        app
+      end
+    end
+  end
+end

data/lib/run_loop/detect_aut/errors.rb

@@ -0,0 +1,126 @@
+module RunLoop
+
+  # @!visibility private
+  class SolutionMissingError < RuntimeError ; end
+
+  # @!visibility private
+  class XcodeprojMissingError < RuntimeError; end
+
+  # @!visibility private
+  class MultipleXcodeprojError < RuntimeError; end
+
+  # @!visibility private
+  class NoSimulatorAppFoundError < RuntimeError; end
+
+  # @!visibility private
+  module DetectAUT
+
+    # @!visibility private
+    module Errors
+
+      # @!visibility private
+      #
+      # Raised when XCODEPROJ is defined, but does not exist
+      def raise_xcodeproj_missing(xcodeproj)
+        raise RunLoop::XcodeprojMissingError,
+%Q[The XCODEPROJ environment variable has been set to:
+
+#{xcodeproj}
+
+but no directory exists at that path.
+
+You should only set XCODEPROJ variable if your Calabash project has more than
+one .xcodeproj directory or your .xcodeproj directory is located above the
+current directory (where you run `cucumber` from).  Calabash will discover the
+.xcodeproj if is below the current working directory.
+
+# .xcodeproj is above the working directory
+$ ls ../*.xcodeproj
+MyApp.xcodeproj
+
+$ XCODEPROJ=../*.xcodeproj cucumber
+
+# There is more than one .xcodeproj
+$ ls *.xcodeproj
+MyiOSApp.xcodeproj
+MyMacApp.xcodeproj
+
+$ XCODEPROJ=MyiOSApp.xcodeproj
+]
+      end
+
+      # @!visibility private
+      #
+      # Raised when there are more than > 1 .xcodeproj in **/*
+      # Is not raised when there are 0 .xcodeproj in **/*
+      #
+      # @param [Array<String>] projects a list of paths to .xcodeproj
+      def raise_multiple_xcodeproj(projects)
+      raise RunLoop::MultipleXcodeprojError,
+%Q[Found multiple .xcodeproj directories:
+
+#{projects.join($-0)}
+
+Which project contains the target of the application you are trying to test?
+
+Set the XCODEPROJ variable to specify the correct .xcodeproj directory.
+
+# Examples
+$ XCODEPROJ="../MyApp.xcodeproj" cucumber
+$ XCODEPROJ="iOS/MyApp.xcodeproj" cucumber
+]
+      end
+
+      # @!visibility private
+      #
+      # Raised when SOLUTION is defined but does not exist
+      def raise_solution_missing(solution)
+        raise RunLoop::SolutionMissingError,
+%Q[The SOLUTION environment variable has been set to:
+
+#{solution}
+
+but no solution exists at that path.
+
+You should only set SOLUTION variable if your .sln is not located in
+the current directory or in the directory just above the current
+directory (where you run `cucumber` from). Calabash will discover the
+.snl if it is in the current working directory or the directory just
+above.
+
+# Calabash will discover solution - don't set SOLUTION
+$ ls *.sln => MyApp.sln
+$ ls ../*.sln => MyApp.sln
+
+# Calabash will _not_ discover solution
+$ ls ../../*.sln => MyApp.sln
+$ SOLUTION=../../MyApp.sln cucumber
+
+$ ls project/*.sln => MyApp.sln
+$ SOLUTION=project/MyApp.sln cucumber
+
+$ ls ~/some/other/directory/*.sln => MyApp.sln
+$ SOLUTION=~/some/other/directory/MyApp.sln
+]
+      end
+
+      # @!visibility private
+      # Raised when no app can found by the discovery algorithm
+      def raise_no_simulator_app_found(search_directories, search_depth)
+        raise RunLoop::NoSimulatorAppFoundError,
+%Q[Recursively searched these directories to depth #{search_depth}:
+
+#{search_directories.join($-0)}
+
+but could not find any .app for the simulator that links the Calabash iOS server.
+
+Make sure you have built your app for a simulator target from Xcode.
+
+If you are testing a stand-alone .app (you don't have an Xcode project), put
+your .app in the same directory (or below) the directory you run `cucumber` from.
+]
+      end
+    end
+  end
+end
+

data/lib/run_loop/detect_aut/xamarin_studio.rb

@@ -0,0 +1,46 @@
+module RunLoop
+  # @!visibility private
+  module DetectAUT
+
+    # @!visibility private
+    module XamarinStudio
+
+      # @!visibility private
+      def xamarin_project?
+        solution_directory != nil
+      end
+
+      # @!visibility private
+      def solution_directory
+        solution = RunLoop::Environment.solution
+
+        if solution && !File.exist?(solution)
+          raise_solution_missing(solution)
+        end
+
+        # SOLUTION defined and exists
+        return File.dirname(solution) if solution
+
+        solution_dir = find_solution_directory
+        return nil if solution_dir.nil?
+
+        solution_dir
+      end
+
+      # @!visibility private
+      def find_solution_directory
+        pwd = Dir.pwd
+        solutions = Dir.glob("#{pwd}/*.sln")
+
+        if solutions.empty?
+          solutions = Dir.glob("#{pwd}/../*.sln")
+        end
+
+        return nil if solutions.empty?
+
+        File.expand_path(File.dirname(solutions.first))
+      end
+    end
+  end
+end
+

data/lib/run_loop/detect_aut/xcode.rb

@@ -0,0 +1,157 @@
+module RunLoop
+  # @!visibility private
+  module DetectAUT
+    # @!visibility private
+    module Xcode
+
+      # @!visibility private
+      def xcode_project?
+        xcodeproj != nil
+      end
+
+      # @!visibility private
+      def xcodeproj
+        xcodeproj = RunLoop::Environment.xcodeproj
+
+        if xcodeproj && !File.directory?(xcodeproj)
+          raise_xcodeproj_missing(xcodeproj)
+        end
+
+        # XCODEPROJ defined and exists
+        return xcodeproj if xcodeproj
+
+        projects = find_xcodeproj
+
+        return nil if projects.empty?
+        return projects[0] if projects.count == 1
+
+        raise_multiple_xcodeproj(projects)
+      end
+
+      # @!visibility private
+      def find_xcodeproj
+        xcode_projects = []
+        Dir.glob("#{Dir.pwd}/**/*.xcodeproj").each do |path|
+          next if ignore_xcodeproj?(path)
+          xcode_projects << path
+        end
+        xcode_projects
+      end
+
+      # @!visibility private
+      def ignore_xcodeproj?(path)
+        path[/CordovaLib/, 0] ||
+          path[/Pods/, 0] ||
+          path[/Carthage/, 0] ||
+          path[/Airship(Kit|Lib)/, 0] ||
+          path[/google-plus-ios-sdk/, 0]
+      end
+
+      # @!visibility private
+      def detect_xcode_apps
+        dirs_to_search = derived_data_search_dirs
+
+        dir_from_prefs = xcode_preferences_search_dir
+        if dir_from_prefs
+          dirs_to_search << dir_from_prefs
+        end
+
+        dirs_to_search << Dir.pwd
+        dirs_to_search.uniq!
+
+        apps = []
+        dirs_to_search.each do |dir|
+          # defined in detect_aut/apps.rb
+          candidates = candidate_apps(dir)
+          apps = apps.concat(candidates)
+        end
+
+        return apps, dirs_to_search
+      end
+
+      # @!visibility private
+      PLIST_KEYS = {
+        :workspace => "WorkspacePath",
+        :shared_build => "IDESharedBuildFolderName",
+        :custom_build => "IDECustomBuildProductsPath"
+      }
+
+      # @!visibility private
+      # TODO Needs unit tests
+      def derived_data_search_dirs
+        project = xcodeproj
+        project_name = File.basename(project)
+        matches = []
+
+        # WorkspacePath could be a .xcodeproj or .xcworkspace
+        #
+        # # Exact match.
+        #     xcodeproj = path/to/MyApp/MyApp.xcodeproj
+        # WorkspacePath = path/to/MyApp/MyApp.xcodeproj
+        #
+        # # CocoaPods projects are often configured like this.  As are legacy
+        # # projects that have been added to a new workspace.
+        #     xcodeproj = path/to/MyApp/MyApp.xcodeproj
+        # WorkspacePath = path/to/MyApp/MyApp.xcworkspace
+        #
+        # # This is the Xcode default when creating new iOS project
+        #     xcodeproj = path/to/MyApp/MyApp/MyApp.xcodeproj
+        # WorkspacePath = path/to/MyApp/MyApp.xcworkspace
+        key = PLIST_KEYS[:workspace]
+        Dir.glob("#{derived_data}/*/info.plist") do |plist|
+          workspace = pbuddy.plist_read(key, plist)
+          if workspace == project
+            matches << File.dirname(plist)
+          else
+            base_dir = File.dirname(workspace)
+            if File.exist?(File.join(base_dir, project_name))
+              matches << File.dirname(plist)
+            elsif !Dir.glob("#{File.dirname(workspace)}/*/#{project_name}").empty?
+              matches << File.dirname(plist)
+            elsif !Dir.glob("#{File.dirname(workspace)}/**/#{project_name}").empty?
+              matches << File.dirname(plist)
+            end
+          end
+        end
+        matches
+      end
+
+      # @!visibility private
+      def xcode_preferences_search_dir
+        plist = xcode_preferences_plist
+
+        shared_build_folder = pbuddy.plist_read(PLIST_KEYS[:shared_build], plist)
+        custom_build_folder = pbuddy.plist_read(PLIST_KEYS[:custom_build], plist)
+
+        if shared_build_folder
+          File.join(derived_data, shared_build_folder, "Products")
+        elsif custom_build_folder
+          File.join(File.dirname(xcodeproj), custom_build_folder)
+        else
+          nil
+        end
+      end
+
+      # @!visibility private
+      def derived_data
+        RunLoop::Environment.derived_data ||
+          File.join(RunLoop::Environment.user_home_directory,
+                    "Library", "Developer", "Xcode", "DerivedData")
+      end
+
+      # @!visibility private
+      def xcode_preferences_plist
+        File.join(RunLoop::Environment.user_home_directory,
+                  "Library",
+                  "Preferences",
+                  "com.apple.dt.Xcode.plist")
+      end
+
+      # @!visibility private
+      def pbuddy
+        @pbuddy ||= RunLoop::PlistBuddy.new
+      end
+    end
+  end
+end
+