_k-standard-goals.shade

use assembly="System.Xml.Linq, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
use namespace="System"
use namespace="System.Globalization"
use namespace="System.IO"
use namespace="System.Linq"
use namespace="System.Threading.Tasks"
use import="BuildEnv"
use import="Environment"
use import="Files"
use import="Json"
use-ci-loggers

default BASE_DIR='${Directory.GetCurrentDirectory()}'
default TARGET_DIR='${Path.Combine(BASE_DIR, "artifacts")}'
default BUILD_DIR='${Path.Combine(TARGET_DIR, "build")}'
default TEST_DIR='${Path.Combine(TARGET_DIR, "test")}'
default Configuration='${E("Configuration")}'
default PACKAGELIST_JSON_FILENAME = 'NuGetPackageVerifier.json'
default SRC_PROJECT_GLOB = "src/*/*.csproj"
default TEST_PROJECT_GLOB = "test/*/*.csproj"
default SAMPLES_PROJECT_GLOB = "samples/*/*.csproj"

@{
  if (string.IsNullOrEmpty(E("BuildNumber")))
  {
    E("BuildNumber", BuildNumber);
  }
  if (string.IsNullOrEmpty(Configuration))
  {
    Configuration = "Debug";
    E("Configuration", Configuration);
  }
}

#--for-ci
  @{
    Configuration = "Release";
    E("Configuration", Configuration);
    if (string.IsNullOrEmpty(E("KOREBUILD_ADD_ASSEMBLY_INFO")))
    {
      E("KOREBUILD_ADD_ASSEMBLY_INFO", "1");
    }

    E("KOREBUILD_VERIFY_NUPKGS", "1");
  }

#restore-npm-modules
  @{
    // Find all dirs that contain a package.json file
    var npmDirs = GetDirectoriesContaining(Directory.GetCurrentDirectory(), "package.json").ToArray();
    var npmOptions = E("KOREBUILD_NPM_INSTALL_OPTIONS") ?? "--quiet --depth 0";
    foreach (var npmDir in npmDirs)
    {
        Npm("install " + npmOptions, npmDir);
    }
  }

#restore-bower-components
  -// Find all dirs that contain a bower.json file
  var bowerDirs = '${GetDirectoriesContaining(Directory.GetCurrentDirectory(), "bower.json")}'
  bower each='var bowerDir in bowerDirs' bowerCommand='install ${E("KOREBUILD_BOWER_INSTALL_OPTIONS")}'

#run-grunt .restore-npm-modules .restore-bower-components target='initialize'
  -// Find all dirs that contain a gruntfile.js file
  var gruntDirs = '${GetDirectoriesContaining(Directory.GetCurrentDirectory(), "gruntfile.js")}'
  grunt each='var gruntDir in gruntDirs'

#clean-bin-folder
  rimraf rimrafDir='bin' if='Directory.Exists("bin")'

#clean-npm-modules
  -// Find all dirs that contain a package.json file
  var npmDirs = '${
    GetDirectoriesContaining(Directory.GetCurrentDirectory(), "package.json")
      .Select(directory => Path.Combine(directory, "node_modules"))
      .Where(directory => Directory.Exists(directory))
  }'
  rimraf each='var rimrafDir in npmDirs'

-// Target order is important because clean-npm-modules may (re)create bin folder.
#deep-clean .clean-npm-modules .clean-bin-folder description='Clean folders that may cause problems for `git clean`.'

#repo-initialize target='initialize'
  use-volatile-feed
  -//dotnet-restore if='!NoRestore'
  @{
    // workaround https://github.com/Microsoft/msbuild/issues/1587
    if (!NoRestore)
    {
      Dotnet("msbuild \"" + Path.Combine(BASE_DIR, ".build/restore.proj") + "\"");
    }
  }

#target-dir-clean target='clean'
  @{
      if (Directory.Exists(TARGET_DIR))
      {
          var directory = new DirectoryInfo(TARGET_DIR);
          directory.Attributes &= ~FileAttributes.ReadOnly;

          foreach (var info in directory.GetFileSystemInfos("*", SearchOption.AllDirectories))
          {
              info.Attributes &= ~FileAttributes.ReadOnly;
          }

          directory.Delete(true);
        }
    }

#build-clean if='Directory.Exists("src")'
  k-clean each='var projectFile in Files.Include("src/*/*.csproj")'

#ci-deep-clean .deep-clean target='clean' if='IsTeamCity'

#build-compile target='compile'
  @{
    var projectGlobs = new List<string>();
    List<string> srcProjects = null;

    if (Directory.Exists("src"))
    {
      Directory.CreateDirectory(TARGET_DIR);

      string commitHash = null;
      if (AddAssemblyInfo)
      {
          var commitHashFile = Path.Combine(TARGET_DIR, "commit");
          GitCommand("rev-parse HEAD >> " + commitHashFile);
          commitHash = File.ReadAllLines(commitHashFile)[0];
      }

      srcProjects = Files.Include(SRC_PROJECT_GLOB).ToList();
      srcProjects.ForEach(projectFile =>
      {
          if (AddAssemblyInfo)
          {
              // var projectText = File.ReadAllText(projectFile);
              // var project = (JsonObject)Json.Deserialize(projectText);
              // var isSharedProject = project.Keys.Contains("shared");
              var isSharedProject = false;
              // We don't want to embed the commit hash in it because
              // the consumers would get that file
              if (!isSharedProject)
              {
                  Console.WriteLine("Embedding commit hash in assembly");
                  var projectFolder = Path.GetDirectoryName(projectFile);
                  var commitHashAttribute = String.Format("[assembly: System.Reflection.AssemblyMetadata(\"CommitHash\", \"{0}\")]", commitHash);

                  var buildInfoFile = Path.Combine(projectFolder, "BuildInfo.generated.cs");
                  File.WriteAllText(buildInfoFile, commitHashAttribute);
              }
          }
      });

      projectGlobs.AddRange(srcProjects);
    }

    if (!BuildSrcOnly && Directory.Exists("test"))
    {
      projectGlobs.AddRange(Files.Include(TEST_PROJECT_GLOB).ToList());
    }

    if (!BuildSrcOnly && Directory.Exists("samples"))
    {
      projectGlobs.AddRange(Files.Include(SAMPLES_PROJECT_GLOB).ToList());
    }

    if (projectGlobs.Any())
    {
      foreach (var project in projectGlobs)
      {
        DotnetBuild(project, Configuration, BuildFramework);
      }
    }
  }

#run-api-check .build-compile target='compile' description='Checks the compiled assemblies against a baseline for potential breaking changes'
  api-check

#build-pack .build-compile target='compile'
  @{
    if (Directory.Exists("src"))
    {
      Directory.CreateDirectory(BUILD_DIR);
      var srcProjects = Files.Include(SRC_PROJECT_GLOB).ToList();
      if (srcProjects != null && srcProjects.Count > 0)
      {
        srcProjects.ForEach(projectFile =>
        {
            DotnetPack(projectFile, BUILD_DIR, Configuration, E("KOREBUILD_DOTNET_PACK_OPTIONS") + " --no-build");
        });

        foreach (var nupkg in Files.Include(Path.Combine(BUILD_DIR, "*/" + Configuration + "/*.nupkg")))
        {
            File.Copy(nupkg, Path.Combine(BUILD_DIR, Path.GetFileName(nupkg)), true);
        }
      }
    }
  }

#native-compile target='compile' if='!IsLinux && Directory.Exists(Path.Combine(BASE_DIR, "src"))'
  var programFilesX86 = '${Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86)}'
  var nativeProjects ='${Files.Include(Path.Combine(BASE_DIR, "src", "**", "*.vcxproj"))}'

  @{
    if (nativeProjects.Any())
    {
      var msbuildVersions = new[] { "14.0", "12.0"};

      for (var i = 0; i < msbuildVersions.Length; i++)
      {
        var msbuildPath =  Path.Combine(programFilesX86, "MSBuild", msbuildVersions[i], "Bin", "MSBuild.exe");
        if (File.Exists(msbuildPath))
        {
          var commonParameters =
            " /p:Configuration=" + Configuration +
            " /p:ProductVersion=1.0.0" +
            " /p:FileRevision=" + E("DNX_ASSEMBLY_FILE_VERSION") +
            " /p:BuildVersion=" + E("DNX_BUILD_VERSION");

          foreach (var project in nativeProjects)
          {
            Directory.CreateDirectory(Path.Combine(Path.GetDirectoryName(project), "bin"));
            Exec(msbuildPath, project + " /p:Platform=Win32" + commonParameters);
            Exec(msbuildPath, project + " /p:Platform=x64" + commonParameters);
          }

          break;
        }

        if (i == msbuildVersions.Length - 1)
        {
          Log.Warn("msbuild version 14 or 12 not found. Please ensure you have the VS 2015 or VS 2013 C++ SDK installed.");
          Environment.Exit(1);
        }
      }
    }
  }

  copy sourceDir='${Path.GetDirectoryName(project)}' include='bin/**/' outputDir='${Path.Combine(BUILD_DIR, Path.GetFileNameWithoutExtension(project))}' overwrite='${true}' each='var project in nativeProjects'

#nuget-verify target='package' description='Verify if all the packages are generated properly'
  @{
      if (Directory.Exists("src") && File.Exists(PACKAGELIST_JSON_FILENAME))
      {
        var verifierDirectory = Directory.EnumerateDirectories(Path.Combine(KoreBuildFolderPath, "nugetpackageverifier")).First();
        Dotnet(
            string.Format("\"{0}\" \"{1}\" \"{2}\"",
            Path.Combine(verifierDirectory, "NuGetPackageVerifier.dll"),
            BUILD_DIR.TrimEnd(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }),
            Path.Combine(BASE_DIR, PACKAGELIST_JSON_FILENAME)));
      }
  }

#nuget-install target='install' description='Install NuGet packages to local repo'
  -if (Directory.Exists("src") && Directory.Exists(BUILD_DIR)) {
    nuget-packages-add sourcePackagesDir='${BUILD_DIR}' targetPackagesDir='${E("PACKAGES_PUBLISH_DIR")}'
    nuget-resilient-publish sourcePackagesDir='${BUILD_DIR}' nugetFeed='${E("NUGET_PUBLISH_FEED")}' if='!string.IsNullOrEmpty(E("NUGET_PUBLISH_FEED"))'
  -}

#xunit-test target='test' if='Directory.Exists("test")'
  @{
    var projectFiles = Files.Include(TEST_PROJECT_GLOB);
    foreach (var projectFile in projectFiles)
    {
        var dir = Path.GetDirectoryName(projectFile);
        if (File.Exists(Path.Combine(dir, ".notest")))
        {
            continue;
        }

        var options = E("KOREBUILD_DOTNET_TEST_OPTIONS");
        if (IsTeamCity)
        {
            // TODO put all trx files in same folder. See https://github.com/Microsoft/vstest/issues/243
            // TODO or use TC logger https://github.com/Microsoft/vstest/issues/254
            options += " --logger:trx ";
        }
        // workaround for https://github.com/Microsoft/vstest/issues/283
        var txt = File.ReadAllText(projectFile);
        var multiTfm = Regex.Match(txt, @"\<TargetFrameworks\>(.+)\<\/TargetFrameworks\>");
        var singleTfm = Regex.Match(txt, @"\<TargetFramework\>(.+)\<\/TargetFramework\>");
        if (multiTfm != null && multiTfm.Success)
        {
          var frameworks = multiTfm.Groups[1]
            .Value
            .Split(new string[] {";"}, StringSplitOptions.RemoveEmptyEntries)
            .Select(s => s.Trim())
            .ToArray();

          foreach (var framework in frameworks)
          {
            if (IsLinux && framework != null && framework.StartsWith("net4"))
            {
              Log.Info("Skipping tests for TFM " + framework + " on this platform");
              continue;
            }

            DotnetTest(projectFile, Configuration, options, framework);
          }
          // end workaround
        }
        else if(singleTfm != null && singleTfm.Success)
        {
          var framework = singleTfm.Groups[1].Value;
          if (IsLinux && framework != null && framework.StartsWith("net4"))
          {
            Log.Info("Skipping tests for TFM " + framework + " on this platform");
          }
          else
          {
            DotnetTest(projectFile, Configuration, options, framework);
          }
        }
        else
        {
          // default invocation
          DotnetTest(projectFile, Configuration, options);
        }
    }
  }


#make-roslyn-fast
  ngen-roslyn

#resx
   @{
     var cultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures | CultureTypes.InstalledWin32Cultures | CultureTypes.SpecificCultures);
     foreach (var file in Directory.EnumerateFiles(BASE_DIR, "*.resx", SearchOption.AllDirectories))
     {
        var splitFileName = Path.GetFileNameWithoutExtension(file).Split(new string[] { "." }, StringSplitOptions.None);

        if (splitFileName.Length > 1)
        {
            var localeString = splitFileName.Last();
            if (!cultures.Any(c => localeString.Equals(c.Name)))
            {
                UpdateResx(file);
            }
        }
        else
        {
            UpdateResx(file);
        }
     }
   }

#--no-restore
  @{ NoRestore = true; }

#--quiet
  @{
    AddToE("KOREBUILD_DOTNET_RESTORE_OPTIONS", "--verbosity minimal");
    AddToE("KOREBUILD_BOWER_INSTALL_OPTIONS", "--quiet");
    AddToE("KOREBUILD_NPM_INSTALL_OPTIONS", "--quiet --depth 0 --progress false");
    Quiet = true;
  }

#--parallel
   @{ ExecuteParallel = true; }

functions @{
    private static bool Quiet { get; set; }
    private static bool NoRestore { get; set; }
    private static bool ExecuteParallel { get; set; }

    string E(string key) { return Environment.GetEnvironmentVariable(key); }
    void E(string key, string value) { Environment.SetEnvironmentVariable(key, value); }
    void AddToE(string key, string append)
    {
      var original = E(key);
      if (string.IsNullOrEmpty(original))
      {
        E(key, append);
      }
      else
      {
        E(key, original + " " + append);
      }
    }

    IEnumerable<string> GetDirectoriesContaining(string path, string searchPattern)
    {
      var sep = Path.DirectorySeparatorChar;
      // Don't include directories that are children of a node_modules or bower_components directory
      return Directory.GetFiles(path, searchPattern, SearchOption.AllDirectories)
                      .Where(p => p.IndexOf(sep + "node_modules" + sep) < 0 &&
                                  p.IndexOf(sep + "bower_components" + sep) < 0 &&
                                  p.IndexOf(sep + "wwwroot" + sep + "lib" + sep) < 0)
                      .Select(p => Path.GetDirectoryName(p))
                      .Distinct();
    }

    bool TestCommand(string program, string commandline)
    {
      // Tests whether a given command succeeds at the command line.
      // Useful for testing whether a given command is installed and on the path, e.g. node
      ProcessStartInfo processStartInfo;

      if(!IsLinux)
      {
        processStartInfo = new ProcessStartInfo {
        UseShellExecute = false,
        FileName = "cmd",
        Arguments = "/C " + program + " " + commandline,
        };
      } else
      {
        processStartInfo = new ProcessStartInfo {
        UseShellExecute = false,
        FileName = program,
        Arguments = commandline,
        };
      }
      try
      {
        Log.Info(string.Format("Testing for command: {0} {1}", program, commandline));
        var process = Process.Start(processStartInfo);
        process.WaitForExit();
        if (process.ExitCode == 0)
        {
          Log.Info("   command found (0 exit code)");
          return true;
        }
        else
        {
          Log.Warn("   command not found (non-0 exit code)");
          return false;
        }
      }
      catch (Exception ex)
      {
        Log.Warn("   command exception: " + ex.ToString());
        Log.Warn("   command not found");
        return false;
      }
    }

    bool BuildSrcOnly
    {
      get { return E("KOREBUILD_BUILD_SRC_ONLY") == "1"; }
    }

    bool AddAssemblyInfo
    {
      get { return E("KOREBUILD_ADD_ASSEMBLY_INFO") == "1"; }
    }

    string BuildFramework
    {
      get { return E("KOREBUILD_BUILD_FRAMEWORK"); }
    }
}

macro name='Exec' program='string' commandline='string'
    exec

macro name='Exec' program='string' commandline='string' workingdir='string'
    exec

macro name='ExecClr' program='string' commandline='string'
    exec-clr

macro name='ExecClr' program='string' commandline='string' workingdir='string'
    exec-clr

macro name="DeleteFolder" delete='string'
    directory

macro name="Copy" sourceDir='string' outputDir='string' include='string' overwrite='bool'
    copy

macro name="CopyFolder" sourceDir='string' outputDir='string' overwrite='bool'
    copy

macro name='Dotnet' command='string'
    dotnet

macro name='Dotnet' command='string' dotnetDir='string'
    dotnet

macro name="DotnetBuild" projectFile='string' configuration='string' framework='string'
    dotnet-build

macro name="DotnetPack" projectFile='string' dotnetPackOutputDir='string' configuration='string' pack_options='string'
    dotnet-pack

macro name="DotnetPublish" projectFile='string' outputFolder='string' framework='string' configuration='string'
    dotnet-publish

macro name="DotnetTest" projectFile='string' configuration='string' test_options='string'
    dotnet-test

macro name="DotnetTest" projectFile='string' configuration='string' test_options='string' framework='string'
    dotnet-test

macro name='Npm' npmCommand='string' npmDir='string'
    npm

macro name="UpdateResx" resxFile='string'
    k-generate-resx

macro name='GitCommand' gitCommand='string'
    git