Rakefile

#!/usr/bin/env ruby

require 'xcodeproj'

$top_level = File.expand_path(File.dirname(__FILE__))

$macOSDeploymentTarget = "11"
$iOSDeploymentTarget = "15.0"

$demos = {
    :osx => ["Glacier2/callback",

             "Ice/async",
             "Ice/asyncInvocation",
             "Ice/bidir",
             "Ice/context",
             "Ice/hello",
             "Ice/interceptor",
             "Ice/invoke",
             "Ice/latency",
             "Ice/minimal",
             "Ice/optional",
             "Ice/throughput",

             "IceDiscovery/hello",
             "IceDiscovery/replication",

             "IceGrid/simple",

             "IceStorm/clock",

             "Manual/printer",
             "Manual/simpleFilesystem"],

    :ios => ["IceDiscovery/helloUI",
             "Ice/helloUI",
             "Chat"]
}

$demo_variants = ["Client", "Server", "Publisher", "Subscriber"]

#
# Default sources for each variant
#
$demo_variant_sources = {
    "Client" => ["Client/*.swift"],
    "Server" => ["Server/*.swift"],
    "Publisher" => ["Publisher/*.swift"],
    "Subscriber" => ["Subscriber/*.swift"]
}

$demo_extra_frameworks = {
    "Glacier2/callback" => ["Glacier2.xcframework"],

    "IceStorm/clock" => ["IceStorm.xcframework"],

    "IceGrid/simple" => ["Glacier2.xcframework", "IceGrid.xcframework"],

    "Chat" => ["Glacier2.xcframework",
                   "MessageKit.xcframework",
                   "InputBarAccessoryView.xcframework"]
}

$demo_resources = {
    "Ice/helloUI" => ["../certs"],
    "IceDiscovery/helloUI" => ["../certs"],
    "IceGrid/simple" => ["IceGrid/simple"] #For adding xml
}

desc "Generate Xcode projects required to build Ice for Swift Demo Applications"
task :iceproj do
    project = Xcodeproj::Project.new("demos.xcodeproj")
    aggregate_target_macos = project.new_aggregate_target("allDemos macOS")
    aggregate_target_ios = project.new_aggregate_target("allDemos iOS")
    group_add_files(project.main_group, "#{project.project_dir}", ["README.md"])
    $demos.each do |platform, demos|
        demos.each do |demo|
            if platform == :ios then
                create_swiftui_targets(project, demo, aggregate_target_ios)
            else
                create_commandline_targets(project, demo, aggregate_target_macos)
            end
        end
    end

    attributes = project.root_object.attributes
    attributes["TargetAttributes"] ||= {}
    project.targets.each do |target|
        attributes["TargetAttributes"][target.uuid] ||= {}
        attributes["TargetAttributes"][target.uuid]["ProvisioningStyle"] = "Automatic"
    end
    project.root_object.development_region = "en"
    project.root_object.known_regions = ["Base", "en"]
    project.build_independent_targets_in_parallel = true

    #
    # Sort the project and save it
    #
    project.sort({:groups_position => :above})
    project.save()
end

task :default => [:iceproj]

def create_commandline_targets(project, demo, aggregate_target)
    $demo_variants.each do |variant|
        if demo_has_variant(demo, variant)
            target = project.new_target(:command_line_tool, target_name(demo, variant), :osx)
            aggregate_target.add_dependency(target)
            target_set_common_build_settings(target, variant.downcase, "$SRCROOT/#{demo}", :osx)

            target.frameworks_build_phases.clear()
            group = project_group(project, demo)
            group_add_files(group, "#{project.project_dir}/#{demo}", ["README.md", "config.*"])
            target_add_files(target, group, "#{project.project_dir}/#{demo}/Sources", ["*.ice"])

            group = project_group(project, "#{demo}/#{variant}")
            target_add_files(target, group, "#{project.project_dir}/#{demo}/Sources",
                             demo_variant_sources(demo, variant))

            target_add_carthage_framework(target, :osx, "IceImpl.xcframework")
            target_add_carthage_framework(target, :osx, "Ice.xcframework")
            target_add_carthage_framework(target, :osx, "PromiseKit.xcframework")
            extra_frameworks = $demo_extra_frameworks[demo] || []
            extra_frameworks.each do |f|
                target_add_carthage_framework(target, :osx, f)
            end

            target_set_framework_build_settings(target, :osx)
            target_add_slice2swift_build_rule(project, target)
        end
    end
end

def create_swiftui_targets(project, demo, aggregate_target)
    target = project.new_target(:application, target_name(demo, ""), :ios)
    aggregate_target.add_dependency(target)
    target_set_common_build_settings(target, product_name(demo), "$SRCROOT/#{demo}", :ios, "$SRCROOT/#{demo}/Info.plist")

    target.frameworks_build_phases.clear()
    group = project_group(project, demo)
    group_add_files(group, "#{project.project_dir}/#{demo}", ["README.md"])
    target_add_files(target, group, "#{project.project_dir}/#{demo}", ["*.swift", "*.ice"])
    if Dir.exists? "#{project.project_dir}/#{demo}/views"
        target_add_files(target, group, "#{project.project_dir}/#{demo}/views", ["*.swift"])
    end
    if Dir.exists? "#{project.project_dir}/#{demo}/models"
        target_add_files(target, group, "#{project.project_dir}/#{demo}/models", ["*.swift"])
    end
    target_add_files(target, group, "#{project.project_dir}/#{demo}", ["*.xcassets"])
    target.add_resources(group_add_files(group, "#{project.project_dir}/#{demo}", ["config.client"]))

    if $demo_resources.include? demo
        target.add_resources(group_add_files(group, "#{project.project_dir}", $demo_resources[demo]))
    end

    target_add_carthage_framework(target, :ios, "IceImpl.xcframework", true)
    target_add_carthage_framework(target, :ios, "Ice.xcframework", true)
    target_add_carthage_framework(target, :ios, "PromiseKit.xcframework", true)

    extra_frameworks = $demo_extra_frameworks[demo] || []
    extra_frameworks.each do |f|
        target_add_carthage_framework(target, :ios, f, true)
    end

    target_set_framework_build_settings(target, :ios)
    target_add_slice2swift_build_rule(project, target)

    if ENV.has_key?("DEVELOPMENT_TEAM") then
        target.build_configurations.each { |config|
            if target.product_type == "com.apple.product-type.application" or
              target.product_type == "com.apple.product-type.bundle" then
                config.build_settings["CODE_SIGN_STYLE"] = "Automatic"
                config.build_settings["CODE_SIGN_IDENTITY"] = "Apple Development"
                config.build_settings["DEVELOPMENT_TEAM"] = ENV["DEVELOPMENT_TEAM"]
            end
        }
    end
    return target
end

def project_group(project, name)
    group = project.main_group
    name.split("/").each { |item|
        new_group = group[item]
        unless new_group
            new_group = group.new_group(item)
        end
        group = new_group
    }
    group
end

def target_name(basename, suffix)
    basename.split("/").map{ |item| item[0].upcase + item[1..-1]}.join() + suffix
end

def product_name(basename)
    basename.split("/")[-1].downcase
end

def target_add_slice2swift_build_rule(project, target, prefix = nil)
    #
    # Add Slice Compiler build rule to the target
    #
    rule = project.new(Xcodeproj::Project::PBXBuildRule)
    rule.compiler_spec = "com.apple.compilers.proxy.script"
    rule.file_type = "pattern.proxy"

    script = <<~SCRIPT
        BREW_PREFIX=$($SHELL -c 'brew --prefix' 2>/dev/null)
        if [ -f "${ICE_HOME-unset}/bin/slice2swift" ]; then
            SLICE2SWIFT="$ICE_HOME/bin/slice2swift"
            SLICEDIR="$ICE_HOME/slice"
        elif [ -f "${BREW_PREFIX-unset}/bin/slice2swift" ]; then
            SLICE2SWIFT=$BREW_PREFIX/bin/slice2swift
            SLICEDIR=$BREW_PREFIX/share/ice/slice
        else
            echo "Failed to locate slice2swift compiler"
            exit 1
        fi

        "$SLICE2SWIFT" -I"$SLICEDIR" -I"$INPUT_FILE_DIR" --output-dir "$DERIVED_FILE_DIR" "$INPUT_FILE_PATH"
    SCRIPT
    rule.script = script
    rule.run_once_per_architecture = "0"

    if prefix then
        rule.name = "Slice Compiler for #{prefix}/*.ice"
        rule.file_patterns = "*/#{prefix}/*.ice"
        rule.output_files = ["$(DERIVED_FILE_DIR)/#{prefix}_$(INPUT_FILE_BASE).swift"]
    else
        rule.name = "Slice Compiler"
        rule.file_patterns = "*.ice"
        rule.output_files = ["$(DERIVED_FILE_DIR)/$(INPUT_FILE_BASE).swift"]
    end
    target.build_rules << rule
end

def group_add_files(group, basedir, patterns, exclude = [])
    files = []
    Dir.chdir(basedir) do
        patterns.each do |p|
            Dir.glob(p) do |file|
                files << file
            end
        end
    end
    files = files.reject { |item| exclude.any? { |pattern| item.match(pattern) } }
    files = files.uniq
    files.map { |file|  group.find_subpath(File.basename(file)) ||  group.new_file("#{basedir}/#{file}") }
end

def target_add_files(target, group, basedir, patterns, excludes = [])
    target.add_file_references(group_add_files(group, basedir, patterns, excludes))
end

def target_add_headers(target, group, basedir, patterns, excludes: [], attributes: ["Public"])
    files = group_add_files(group, basedir, patterns, excludes)
    if attributes.include? "Public" then
        files.each do |file|
            header = target.headers_build_phase.add_file_reference(file)
            header.settings = { "ATTRIBUTES" => attributes }
        end
    end
end

def target_set_common_build_settings(target, product, build_dir, platform, plist = nil)
    target.build_configurations.each { |config|
        config.build_settings["ENABLE_TESTABILITY"] = "NO"
        config.build_settings["CODE_SIGN_STYLE"] = "Automatic"
        config.build_settings["CURRENT_PROJECT_VERSION"] = "3.7.10"
        config.build_settings["DYLIB_CURRENT_VERSION"] = "3.7.10"
        config.build_settings["DYLIB_COMPATIBILITY_VERSION"] = "0"
        config.build_settings["SWIFT_VERSION"] = "5.0"
        if plist != nil then
            config.build_settings["INFOPLIST_FILE"] = plist
        end
        config.build_settings["PRODUCT_NAME"] = product
        config.build_settings["CONFIGURATION_BUILD_DIR"] = "#{build_dir}/Build"
        config.build_settings["PRODUCT_BUNDLE_IDENTIFIER"] = "com.zeroc.demo.#{product}"

        if platform == :osx
            config.build_settings["MACOSX_DEPLOYMENT_TARGET"] = $macOSDeploymentTarget
        else
            config.build_settings["IPHONEOS_DEPLOYMENT_TARGET"] = $iOSDeploymentTarget
        end
    }
end

def target_set_framework_build_settings(target, platform)
    carthage_prefix = (platform == :osx) ? "Mac" : "iOS"
    target.build_configurations.each { |config|
        config.build_settings["FRAMEWORK_SEARCH_PATHS"] = "$SRCROOT/Carthage/Build/"
        if carthage_prefix == "Mac" then
            config.build_settings["LD_RUNPATH_SEARCH_PATHS"] = "@executable_path"
        end
    }
end

def target_add_carthage_framework(target, platform, framework, copy=false)
    group = target.project.frameworks_group[(platform == :osx ? "OS X" : "iOS")]
    group_add_files(group, "#{$top_level}/Carthage/Build", [framework]).each do |ref|
        target.frameworks_build_phases.add_file_reference(ref, true)

        if copy then
            embed_frameworks_build_phase = target.build_phases.find { |bp| bp.display_name == "Embed Frameworks" }
            if !embed_frameworks_build_phase then
                embed_frameworks_build_phase = target.new_copy_files_build_phase('Embed Frameworks')
                embed_frameworks_build_phase.dst_subfolder_spec = "10" # Frameworks
            end
            build_file = embed_frameworks_build_phase.add_file_reference(ref, true)
            # add 'CodeSignOnCopy' to the list to enable signing
            build_file.settings = { 'ATTRIBUTES' => ['RemoveHeadersOnCopy', 'CodeSignOnCopy'] }
        end

    end

end

#
# Check if the test include the given variant
#
def demo_has_variant(demo, variant)
    return File.file?("#{demo}/Sources/#{variant}/main.swift") ||
           File.file?("#{demo}/#{variant}/AppDelegate.swift")
end

def demo_variant_sources(demo, variant)
    $demo_variant_sources[variant] || []
end