Rakefile

require 'bundler'
Bundler::GemHelper.install_tasks

begin
  require 'rspec/core/rake_task'

  RSpec::Core::RakeTask.new(:spec) do |task|
    task.pattern = 'spec/lib/**{,/*/**}/*_spec.rb'
  end

  RSpec::Core::RakeTask.new(:unit) do |task|
    task.pattern = 'spec/lib/**{,/*/**}/*_spec.rb'
  end

  RSpec::Core::RakeTask.new(:integration) do |task|
    task.pattern = 'spec/integration/**{,/*/**}/*_spec.rb'
  end

rescue LoadError => _
end

def colorize(string, color)
  "\033[#{color}m#{string}\033[0m"
end

def cyan(string)
  colorize(string, 36)
end

def green(string)
  colorize(string, 32)
end

def magenta(string)
  colorize(string, 35)
end

def log_unix_cmd(msg)
  puts cyan("EXEC: #{msg}") if msg
end

def log_info(msg)
  puts green("INFO: #{msg}") if msg
end

def banner(msg)
  puts ""
  puts magenta("######## #{msg} ########")
  puts ""
end

def rm_path(path)
  log_info("Deleting #{path}")
  FileUtils.rm_rf(path)
end

def expect_path_to_repo(name)
  local = File.expand_path(File.join(".", name))
  return local if File.exist?(local)

  up_one = File.expand_path(File.join("..", name))
  return up_one if File.exist?(up_one)

  raise %Q[
Could not find repo #{name}.  Checked these two directories:

#{local}
#{up_one}

To specify a non-standard location for these repositories, use:

*   DEVICEAGENT_PATH=path/to/DeviceAgent.iOS
* IOS_DEVICE_MANAGER=path/to/iOSDeviceManager
]
end

def ditto(source, target)
  args = ["ditto", source, target]

  log_unix_cmd("xcrun #{args.join(" ")}")

  result = system("xcrun", *args)
  if !result
    raise %Q[Could not copy
source = #{source}
target = #{target}
]
  else
    log_info "Installed #{source} to #{target}"
  end
end

def ditto_zip(source, target)
  args = ["ditto", "-ck", "--rsrc", "--sequesterRsrc", "--keepParent",
          source, target]

  log_unix_cmd("xcrun #{args.join(" ")}")

  result = system("xcrun", *args)
  if !result
    raise %Q[Could not zip:
source = #{source}
target = #{target}
    ]
  else
    log_info "Installed #{source} to #{target}"
  end
end

def ditto_unzip(source, target)
  args = ["ditto", "-xk", source, target]

  log_unix_cmd("xcrun #{args.join(" ")}")

  result = system("xcrun", *args)
  if !result
    raise %Q[Could not unzip:
source = #{source}
target = #{target}
]
  end
end

def checkout(path)
  args = ["checkout", path]

  log_unix_cmd("git #{args.join(" ")}")

  result = system("git", *args)
  if !result
    raise %Q[Could not checkout: #{path}]
  end
end

def ensure_valid_core_simulator_service
  max_tries = 3
  valid = false
  3.times do |try|
    valid = valid_core_simulator_service?
    break if valid
    log_info("Invalid CoreSimulator service for active Xcode: try #{try + 1} of #{max_tries}")
  end
  if valid
    log_info("CoreSimulatorService is valid")
  else
    puts "CoreSimulatorService is invalid, try running again."
    exit 1
  end
end

def valid_core_simulator_service?
  require "run_loop/shell"
  args = ["xcrun", "simctl", "help"]

  begin
    hash = RunLoop::Shell.run_shell_command(args)
    hash[:exit_status] == 0 &&
      !hash[:out][/Failed to locate a valid instance of CoreSimulatorService/]
  rescue RunLoop::Shell::Error => _
    false
  end
end

def create_calabash_keychain
  require "run_loop/environment"
  path = File.join("..", "calabash-codesign")

  if !File.exist?(path)
    path = File.join(RunLoop::Environment.user_home_directory,
                     ".calabash", "calabash-codesign")
  end

  if File.exist?(path)
    Dir.chdir(path) do
      args = ["apple/create-keychain.sh"]
      hash = RunLoop::Shell.run_shell_command(args)
      if hash[:exit_status] != 0
        raise %Q[
Failed to create the codesigning keychain:

#{hash[:out]}

]
      else
        log_info("Created the Calabash.keychain")
      end
    end
  else
   log_info("Cannot create the Calabash.keychain")
  end
end

namespace :device_agent do

  def device_agent
    @device_agent_path ||= lambda do
      path = ENV["DEVICE_AGENT"] || expect_path_to_repo("DeviceAgent.iOS")
      log_info "Using DEVICEAGENT_PATH=#{path}"
      path
    end.call
  end

  def app_dir
    @app_dir ||= File.join(device_agent_dir, "app", "DeviceAgent-Runner.app")
  end
  
  def app_zip
    @app_zip ||= "#{app_dir}.zip"
  end
  
  def ipa_dir
    @ipa_dir ||= File.join(device_agent_dir, "ipa", "DeviceAgent-Runner.app")
  end
  
  def ipa_zip
    @ipa_zip ||= "#{ipa_dir}.zip"
  end

  def device_agent_dir
    @device_agent_dir ||= begin
      dir = File.join(".", "lib", "run_loop", "device_agent")
      File.expand_path(dir)
    end
  end
  
  def cbx_paths
    @cbx_paths ||= begin
      [
        File.expand_path(File.join(app_dir, "..", "CBX-Runner.app")),
        File.expand_path(File.join(app_dir, "..", "CBX-Runner.app.zip")),
        File.expand_path(File.join(ipa_dir, "..", "CBX-Runner.app")),
        File.expand_path(File.join(ipa_dir, "..", "CBX-Runner.app.zip")),
      ]
    end
  end

  desc "Install DeviceAgent binaries"
  task :install => [:clean, :build, :expand]

  task :build do
    banner("Building")

    # Memoize base target directory
    device_agent_dir

    ensure_valid_core_simulator_service

    create_calabash_keychain

    Dir.chdir(device_agent) do
      result = system("make", "ipa-agent")
      if !result
        raise "Could not build DeviceAgent-runner.app for physical devices"
      end

      result = system("make", "app-agent")
      if !result
        raise "Could not build DeviceAgent-runner.app for iOS Simulators"
      end

      banner("Installing DeviceAgent to run_loop")

      ditto_zip(
        File.join("Products", "app", "DeviceAgent", "DeviceAgent-Runner.app"),
        app_zip
      )

      ditto_zip(
        File.join("Products", "ipa", "DeviceAgent", "DeviceAgent-Runner.app"),
        ipa_zip
      )
    end
  end

  desc "Remove DeviceAgent binaries"
  task :clean do
    banner("Cleaning")

    log_info("Removing legacy artifacts")
    cbx_paths.each { |path| FileUtils.rm_rf(path) }

    rm_path(app_dir)
    rm_path(ipa_dir)
    rm_path(app_zip)
    rm_path(ipa_zip)
  end

  desc "Remove DeviceAgent binaries, but leave the original .zip files"
  task :uninstall do
    banner("Uninstalling")
    rm_path(app_dir)
    rm_path(ipa_dir)
  end

  desc "Remove existing files and the DeviceAgent .zip files"
  task :expand do
    banner("Expanding")

    banner("Uninstalling")
    rm_path(app_dir)
    rm_path(ipa_dir)

    Dir.chdir(device_agent_dir) do
      ditto_unzip(app_zip, File.join(device_agent_dir, "app"))
      ditto_unzip(ipa_zip, File.join(device_agent_dir, "ipa"))
    end
  end

  desc "Roll back changes to DeviceAgent binaries; does not touch client.rb"
  task :checkout do
    banner("Git Checkout")
    checkout(app_zip)
    checkout(ipa_zip)
  end
end

namespace :idm do

  def ios_device_manager
    @ios_device_manager_path ||= lambda do
      path = ENV["IOS_DEVICE_MANAGER"] || expect_path_to_repo("iOSDeviceManager")
      log_info "Using iOSDeviceManager=#{path}"
      @ios_device_manager_path = path
    end.call
  end

  def frameworks_dir
    @frameworks_dir ||= File.join(device_agent_dir, "Frameworks")
  end
  
  def frameworks_zip
    @frameworks_zip ||= "#{frameworks_dir}.zip"
  end

  def bin
    @bin ||= File.join(device_agent_dir, "bin", "iOSDeviceManager")
  end
  
  def license
    @license ||= File.join(device_agent_dir, "bin", "iOSDeviceManager.LICENSE")
  end
  
  def cli_json
    @cli_json ||= File.join(device_agent_dir, "bin", "CLI.json")
  end

  desc "Install iOSDeviceManager binaries"
  task :install => [:clean, :build, :expand]

  task :build do
    banner("Building")

    # Memoize base target directory
    device_agent_dir

    ensure_valid_core_simulator_service

    create_calabash_keychain

    Dir.chdir(ios_device_manager) do
      result = system("make", "build")
      if !result
        raise "Could not build iOSDeviceManager"
      end

      banner("Installing iOSDeviceManager to run_loop")

      ditto(File.join("Products", "iOSDeviceManager"), bin)
      ditto(File.join(".", "LICENSE"),
            File.expand_path(File.join(bin, "..", "iOSDeviceManager.LICENSE")))
      ditto_zip("Frameworks", frameworks_zip)
    end
  end

  desc "Remove iOSDeviceManager binaries"
  task :clean do
    banner("Cleaning")

    rm_path(frameworks_dir)
    rm_path(frameworks_zip)
    rm_path(bin)
    rm_path(license)
    rm_path(cli_json)
  end

  desc "Remove iOSDeviceManager binaries, but leave the original .zip files"
  task :uninstall do
    banner("Uninstalling")
    rm_path(frameworks_dir)
  end

  desc "Remove existing files and the iOSDeviceManager .zip files"
  task :expand do
    banner("Expanding")

    if Dir.exist?(frameworks_dir) then
      banner("Uninstalling")
      rm_path(frameworks_dir)
    end

    Dir.chdir(device_agent_dir) do
      ditto_unzip(frameworks_zip, device_agent_dir)
    end
  end

  desc "Roll back changes to iOSDeviceManager binaries; does not touch client.rb"
  task :checkout do
    banner("Git Checkout")
    checkout(bin)
    checkout(frameworks_zip)
  end
end