protected YamlMapping CreateKeyValue(string key, string value)
{
var kv = new YamlMapping();
kv[key] = new YamlValue(value);
return(kv);
}
public void TrackerAssignmentTest()
{
var tracker = new YamlNodeTracker();
var stream = new YamlStream(tracker);
var document = new YamlDocument();
var sequence = new YamlSequence();
document.Contents = sequence;
var mapping = new YamlMapping();
sequence.Add(mapping);
var key = new YamlValue("key");
var value = new YamlValue("value");
var eventList = new List <TrackerEventArgs>();
tracker.TrackerEvent += (sender, args) => eventList.Add(args);
mapping[key] = value;
Assert.IsNull(document.Tracker);
Assert.IsNull(sequence.Tracker);
Assert.IsNull(mapping.Tracker);
Assert.IsNull(key.Tracker);
Assert.IsNull(value.Tracker);
stream.Add(document);
Assert.AreEqual(tracker, document.Tracker);
Assert.AreEqual(tracker, sequence.Tracker);
Assert.AreEqual(tracker, mapping.Tracker);
Assert.AreEqual(tracker, key.Tracker);
Assert.AreEqual(tracker, value.Tracker);
Assert.AreEqual(4, eventList.Count);
Assert.IsTrue(eventList[0] is MappingPairAdded);
Assert.IsTrue(eventList[1] is SequenceElementAdded);
Assert.IsTrue(eventList[2] is DocumentContentsChanged);
Assert.IsTrue(eventList[3] is StreamDocumentAdded);
eventList.Clear();
var key2 = new YamlValue("key2");
var value2 = new YamlValue("value2");
mapping[key2] = value2;
Assert.AreEqual(1, eventList.Count);
Assert.IsTrue(eventList[0] is MappingPairAdded);
}
public static ImplPackageYaml fromYaml(YamlValue obj)
{
var languages = new Dictionary <string, ImplPkgLanguage> {
};
var langDict = obj.dict("languages");
if (langDict != null)
{
foreach (var langName in Object.keys(langDict))
{
languages.set(langName, ImplPkgLanguage.fromYaml(langDict.get(langName)));
}
}
return(new ImplPackageYaml(obj.dbl("file-version"), obj.str("vendor"), obj.str("name"), obj.str("description"), obj.str("version"), obj.strArr("includes"), obj.arr("implements").map(impl => ImplPkgImplementation.fromYaml(impl)), languages));
}
public object ReadYaml(ref ObjectContext objectContext)
{
if (objectContext.Descriptor.Type == typeof(YamlNode))
{
if (objectContext.Reader.Accept <MappingStart>())
{
return(YamlMapping.Load(objectContext.Reader, new YamlNodeTracker()));
}
if (objectContext.Reader.Accept <SequenceStart>())
{
return(YamlSequence.Load(objectContext.Reader, new YamlNodeTracker()));
}
if (objectContext.Reader.Accept <Scalar>())
{
return(YamlValue.Load(objectContext.Reader, new YamlNodeTracker()));
}
}
if (objectContext.Descriptor.Type == typeof(YamlMapping))
{
if (objectContext.Reader.Accept <MappingStart>())
{
return(YamlMapping.Load(objectContext.Reader, new YamlNodeTracker()));
}
throw new YamlException($"Expected {nameof(MappingStart)} but did not find it");
}
if (objectContext.Descriptor.Type == typeof(YamlSequence))
{
if (objectContext.Reader.Accept <SequenceStart>())
{
return(YamlSequence.Load(objectContext.Reader, new YamlNodeTracker()));
}
throw new YamlException($"Expected {nameof(SequenceStart)} but did not find it");
}
if (objectContext.Descriptor.Type == typeof(YamlValue))
{
if (objectContext.Reader.Accept <Scalar>())
{
return(YamlValue.Load(objectContext.Reader, new YamlNodeTracker()));
}
throw new YamlException($"Expected {nameof(Scalar)} but did not find it");
}
throw new YamlException($"{objectContext.Descriptor.Type} is not a supported {nameof(YamlNode)} type");
}
public void SubscriberTest()
{
var file = System.Reflection.Assembly.GetExecutingAssembly()
.GetManifestResourceStream("SharpYaml.Tests.files.test12.yaml");
var childrenAdded = 0;
var tracker = new YamlNodeTracker();
var fileStream = new StreamReader(file);
var yaml = YamlStream.Load(fileStream, tracker);
var mapping1 = (YamlMapping)((YamlSequence)yaml[0].Contents)[1];
var mapping2 = (YamlMapping)((YamlSequence)yaml[0].Contents)[2];
var handler = new SubscriberHandler();
tracker.Subscribe(handler, null, "A");
tracker.Subscribe(handler, tracker.GetPaths(yaml[0].Contents)[0], "B");
tracker.Subscribe(handler, tracker.GetPaths(mapping1)[0], "C");
mapping1["key 1"] = new YamlValue("Bla");
Assert.AreEqual(1, handler.ACalls);
Assert.AreEqual(1, handler.BCalls);
Assert.AreEqual(1, handler.CCalls);
mapping2[0] = new KeyValuePair <YamlElement, YamlElement>(new YamlValue("K"), new YamlValue("V"));
Assert.AreEqual(2, handler.ACalls);
Assert.AreEqual(2, handler.BCalls);
Assert.AreEqual(1, handler.CCalls);
((YamlSequence)yaml[0].Contents).Add(new YamlValue("5"));
Assert.AreEqual(3, handler.ACalls);
Assert.AreEqual(3, handler.BCalls);
Assert.AreEqual(1, handler.CCalls);
}
public static ProjectTemplateMeta fromYaml(YamlValue obj)
{
return(new ProjectTemplateMeta(obj.str("language"), obj.str("destination-dir"), obj.str("package-dir"), obj.strArr("template-files")));
}
public void ApplySettings(IActivityMonitor m)
{
if (!this.CheckCurrentBranch(m))
{
return;
}
YamlMapping firstMapping = GetFirstMapping(m, true);
if (firstMapping == null)
{
return;
}
var solution = _driver.GetSolution(m, allowInvalidSolution: true);
if (solution == null)
{
return;
}
// We don't use AppVeyor for private repositories.
if (!GitFolder.IsPublic)
{
if (TextContent != null)
{
m.Log(LogLevel.Info, "The project is private, so we don't use Appveyor and the Appveyor.yml is not needed.");
Delete(m);
}
return;
}
// We currently always use AppVeyor when the repository is public.
YamlMapping env = FindOrCreateYamlElement(m, firstMapping, "environment");
if (env == null)
{
return;
}
var passphrase = _keyStore.GetSecretKey(m, SolutionDriver.CODECAKEBUILDER_SECRET_KEY, false);
if (passphrase != null)
{
var central = KeyVault.DecryptValues(_sharedState.CICDKeyVault, passphrase);
if (central.TryGetValue(APPVEYOR_ENCRYPTED_CODECAKEBUILDER_SECRET_KEY, out var appveyorSecure))
{
env[SolutionDriver.CODECAKEBUILDER_SECRET_KEY] = CreateKeyValue("secure", appveyorSecure);
}
else
{
m.Warn($"Update of {SolutionDriver.CODECAKEBUILDER_SECRET_KEY} encrypted secure key has been skipped: {APPVEYOR_ENCRYPTED_CODECAKEBUILDER_SECRET_KEY} key should be defined in CICDKeyVault.");
}
}
else
{
m.Info($"Update of {SolutionDriver.CODECAKEBUILDER_SECRET_KEY} encrypted secure skipped.");
}
// Remove obsolete environment variables definitions.
env.Remove("NUGET_API_KEY");
env.Remove("MYGET_RELEASE_API_KEY");
env.Remove("MYGET_PREVIEW_API_KEY");
env.Remove("MYGET_CI_API_KEY");
env.Remove("CK_DB_TEST_MASTER_CONNECTION_STRING");
env.Remove("AZURE_FEED_SIGNATURE_OPENSOURCE_PAT");
env.Remove("AZURE_FEED_PAT");
env.Remove("VSS_NUGET_EXTERNAL_FEED_ENDPOINTS");
if (_solutionSpec.SqlServer != null)
{
env["SqlServer/MasterConnectionString"] = new YamlValue($"Server=(local)\\SQL{_solutionSpec.SqlServer.ToUpperInvariant()};Database=master;User ID=sa;Password=Password12!");
}
//
firstMapping.Remove(new YamlValue("init"));
if (_solutionSpec.SqlServer != null)
{
firstMapping["services"] = new YamlValue("mssql" + _solutionSpec.SqlServer.ToLowerInvariant());
}
var install = new YamlSequence();
// Temporary: installs the 6.9.0 of npm.
if (solution.GeneratedArtifacts.Any(g => g.Artifact.Type.Name == "NPM"))
{
install.Add(CreateKeyValue("cmd", "npm install -g [email protected]"));
install.Add(CreateKeyValue("ps", "Install-Product node 12"));
}
firstMapping["install"] = install;
firstMapping["version"] = new YamlValue("build{build}");
firstMapping["image"] = new YamlValue("Visual Studio 2019");
firstMapping["clone_folder"] = new YamlValue("C:\\CKli-World\\" + GitFolder.SubPath.Path.Replace('/', '\\'));
EnsureDefaultBranches(firstMapping);
SetSequence(firstMapping, "build_script", new YamlValue("dotnet run --project CodeCakeBuilder -nointeraction"));
firstMapping["test"] = new YamlValue("off");
firstMapping["artifacts"] = new YamlSequence()
{
new YamlMapping()
{
["path"] = new YamlValue(@"'**\*.log'"),
["name"] = new YamlValue("Log file")
},
new YamlMapping()
{
["path"] = new YamlValue(@"'**\*.trx'"),
["name"] = new YamlValue("Visual studio test results file")
},
new YamlMapping()
{
["path"] = new YamlValue(@"'**\Tests\**\TestResult*.xml'"),
["name"] = new YamlValue("NUnit tests result files")
},
new YamlMapping()
{
["path"] = new YamlValue(@"'**Tests\**\Logs\**\*'"),
["name"] = new YamlValue("Log files")
}
};
CreateOrUpdate(m, YamlMappingToString(m));
}
protected void EnsureKeyValue(YamlMapping m, string key, string value)
{
m[key] = new YamlValue(value);
}
public static InterfaceYaml fromYaml(YamlValue obj)
{
return(new InterfaceYaml(obj.dbl("file-version"), obj.str("vendor"), obj.str("name"), obj.dbl("version"), obj.str("definition-file"), obj.arr("dependencies").map(dep => new InterfaceDependency(dep.str("name"), dep.dbl("minver")))));
}
public static ImplPkgLanguage fromYaml(YamlValue obj)
{
return(new ImplPkgLanguage(obj.str("id"), obj.str("package-dir"), obj.strArr("generator-plugins"), obj.str("native-src-dir"), obj.arr("native-dependencies").map(impl => ImplPkgNativeDependency.fromYaml(impl))));
}
public static ImplPkgNativeDependency fromYaml(YamlValue obj)
{
return(new ImplPkgNativeDependency(obj.str("name"), obj.str("version")));
}
public static ImplPkgImplementation fromYaml(YamlValue obj)
{
return(new ImplPkgImplementation(ImplPkgImplIntf.fromYaml(obj.obj("interface")), obj.str("language"), obj.strArr("native-includes"), obj.str("native-include-dir")));
}
public static ImplPkgImplIntf fromYaml(YamlValue obj)
{
return(new ImplPkgImplIntf(obj.str("name"), obj.dbl("minver"), obj.dbl("maxver")));
}
