From 1f55b94d2a0a5a6b7da058e10006d3e0a1aeac18 Mon Sep 17 00:00:00 2001 From: Jessica Date: Fri, 11 May 2018 11:38:51 -0400 Subject: [PATCH] Add .NET Standard build and align project structure and style rules with cakebuild/cake --- ...entOrEnvironmentVariableAlias_BoolTests.cs | 93 +++++++++++-------- ...tOrEnvironmentVariableAlias_StringTests.cs | 73 +++++++++------ .../Cake.ArgumentHelpers.Tests.csproj | 75 +++++---------- Cake.ArgumentHelpers.Tests/packages.config | 8 -- .../ArgumentOrEnvironmentVariableAlias.cs | 26 ++++-- .../Cake.ArgumentHelpers.csproj | 88 +++++++----------- .../Properties/AssemblyInfo.cs | 2 - Cake.ArgumentHelpers/packages.config | 6 -- Cake.ruleset | 37 ++++++++ Shared.msbuild | 57 ++++++++++++ Test.ruleset | 49 ++++++++++ stylecop.json | 32 +++++++ xunit.runner.json | 1 + 13 files changed, 347 insertions(+), 200 deletions(-) delete mode 100644 Cake.ArgumentHelpers.Tests/packages.config delete mode 100644 Cake.ArgumentHelpers/packages.config create mode 100644 Cake.ruleset create mode 100644 Shared.msbuild create mode 100644 Test.ruleset create mode 100644 stylecop.json create mode 100644 xunit.runner.json diff --git a/Cake.ArgumentHelpers.Tests/ArgumentOrEnvironmentVariableAlias_BoolTests.cs b/Cake.ArgumentHelpers.Tests/ArgumentOrEnvironmentVariableAlias_BoolTests.cs index 89c8baa..9a09441 100644 --- a/Cake.ArgumentHelpers.Tests/ArgumentOrEnvironmentVariableAlias_BoolTests.cs +++ b/Cake.ArgumentHelpers.Tests/ArgumentOrEnvironmentVariableAlias_BoolTests.cs @@ -1,16 +1,18 @@ -using NUnit.Framework; +using System; using Cake.Core; using Moq; +using Xunit; -namespace Cake.ArgumentHelpers.Tests { - [TestFixture()] - public class ArgumentOrEnvironmentVariableAlias_BoolTests { - Mock cakeContextMock; - Mock cakeArgumentsMock; - Mock cakeEnvironmentMock; +namespace Cake.ArgumentHelpers.Tests +{ + public class ArgumentOrEnvironmentVariableAlias_BoolTests : IDisposable + { + private Mock cakeContextMock; + private Mock cakeArgumentsMock; + private Mock cakeEnvironmentMock; - [SetUp] - public void Setup() { + public ArgumentOrEnvironmentVariableAlias_BoolTests() + { cakeContextMock = new Mock(); cakeArgumentsMock = new Mock(); cakeEnvironmentMock = new Mock(); @@ -18,17 +20,20 @@ namespace Cake.ArgumentHelpers.Tests { cakeContextMock.Setup(cakeContext => cakeContext.Environment).Returns(cakeEnvironmentMock.Object); } - void SetupVariables(string key, string environmentPrefix, bool? argumentValue, bool? environmentValue) { + private void SetupVariables(string key, string environmentPrefix, bool? argumentValue, bool? environmentValue) + { bool hasArgument = argumentValue != null; cakeArgumentsMock.Setup(x => x.HasArgument(key)).Returns(hasArgument); - if (hasArgument) { + if (hasArgument) + { cakeArgumentsMock.Setup(x => x.GetArgument(key)).Returns(argumentValue.ToString()); } cakeEnvironmentMock.Setup(x => x.GetEnvironmentVariable(environmentPrefix + key)).Returns(environmentValue != null ? environmentValue.Value.ToString() : null); } - [Test] - public void TrueArgumentAndNullEnvironment_ReturnsTrue() { + [Fact] + public void TrueArgumentAndNullEnvironment_ReturnsTrue() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; bool? testArgumentValue = true; @@ -39,10 +44,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = true; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, true); - Assert.AreEqual(expected, actual, "Didn't find Argument variable."); + Assert.Equal(expected, actual); } - [Test] - public void FalseArgumentAndNullEnvironment_ReturnsFalse() { + [Fact] + public void FalseArgumentAndNullEnvironment_ReturnsFalse() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; bool? testArgumentValue = false; @@ -53,10 +59,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = false; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, true); - Assert.AreEqual(expected, actual, "Didn't find Argument variable."); + Assert.Equal(expected, actual); } - [Test] - public void NullArgumentAndTrueEnvironment_ReturnsTrue() { + [Fact] + public void NullArgumentAndTrueEnvironment_ReturnsTrue() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; bool? testArgumentValue = null; @@ -67,10 +74,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = true; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, true); - Assert.AreEqual(expected, actual, "Didn't find Environment variable."); + Assert.Equal(expected, actual); } - [Test] - public void NullArgumentAndFalseEnvironment_ReturnsFalse() { + [Fact] + public void NullArgumentAndFalseEnvironment_ReturnsFalse() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; bool? testArgumentValue = null; @@ -81,10 +89,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = false; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, true); - Assert.AreEqual(expected, actual, "Didn't find Environment variable."); + Assert.Equal(expected, actual); } - [Test] - public void NullArgumentAndTrueEnvironmentWithoutPrefix_ReturnsTrue() { + [Fact] + public void NullArgumentAndTrueEnvironmentWithoutPrefix_ReturnsTrue() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = (string)null; bool? testArgumentValue = null; @@ -95,10 +104,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = true; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, true); - Assert.AreEqual(expected, actual, "Didn't find Environment variable without prefix."); + Assert.Equal(expected, actual); } - [Test] - public void NullArgumentAndTrueEnvironmentNoPrefixOverload_ReturnsTrue() { + [Fact] + public void NullArgumentAndTrueEnvironmentNoPrefixOverload_ReturnsTrue() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = (string)null; bool? testArgumentValue = null; @@ -109,10 +119,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = true; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, true); - Assert.AreEqual(expected, actual, "Didn't find Environment variable without prefix."); + Assert.Equal(expected, actual); } - [Test] - public void TrueArgumentAndTrueEnvironment_ReturnsTrue() { + [Fact] + public void TrueArgumentAndTrueEnvironment_ReturnsTrue() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; bool? testArgumentValue = true; @@ -123,10 +134,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = true; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, true); - Assert.AreEqual(expected, actual, "Didn't find variable value from either source."); + Assert.Equal(expected, actual); } - [Test] - public void TrueArgumentAndFalseEnvironment_ReturnsTrue() { + [Fact] + public void TrueArgumentAndFalseEnvironment_ReturnsTrue() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; bool? testArgumentValue = true; @@ -137,10 +149,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = true; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, true); - Assert.AreEqual(expected, actual, "Explicit argument variable didn't override opposite environment variable."); + Assert.Equal(expected, actual); } - [Test] - public void FalseArgumentAndTrueEnvironment_ReturnsFalse() { + [Fact] + public void FalseArgumentAndTrueEnvironment_ReturnsFalse() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; bool? testArgumentValue = false; @@ -151,7 +164,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = false; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, true); - Assert.AreEqual(expected, actual, "Explicit argument variable didn't override opposite environment variable."); + Assert.Equal(expected, actual); + } + + public void Dispose() + { } } } diff --git a/Cake.ArgumentHelpers.Tests/ArgumentOrEnvironmentVariableAlias_StringTests.cs b/Cake.ArgumentHelpers.Tests/ArgumentOrEnvironmentVariableAlias_StringTests.cs index 6b751fa..349de79 100644 --- a/Cake.ArgumentHelpers.Tests/ArgumentOrEnvironmentVariableAlias_StringTests.cs +++ b/Cake.ArgumentHelpers.Tests/ArgumentOrEnvironmentVariableAlias_StringTests.cs @@ -1,16 +1,18 @@ -using NUnit.Framework; +using System; using Cake.Core; using Moq; +using Xunit; -namespace Cake.ArgumentHelpers.Tests { - [TestFixture()] - public class ArgumentOrEnvironmentVariableAlias_StringTests { - Mock cakeContextMock; - Mock cakeArgumentsMock; - Mock cakeEnvironmentMock; +namespace Cake.ArgumentHelpers.Tests +{ + public class ArgumentOrEnvironmentVariableAlias_StringTests : IDisposable + { + private Mock cakeContextMock; + private Mock cakeArgumentsMock; + private Mock cakeEnvironmentMock; - [SetUp] - public void Setup() { + public ArgumentOrEnvironmentVariableAlias_StringTests() + { cakeContextMock = new Mock(); cakeArgumentsMock = new Mock(); cakeEnvironmentMock = new Mock(); @@ -18,10 +20,12 @@ namespace Cake.ArgumentHelpers.Tests { cakeContextMock.Setup(cakeContext => cakeContext.Environment).Returns(cakeEnvironmentMock.Object); } - void SetupVariables(string key, string environmentPrefix, string argumentValue, string environmentValue) { + private void SetupVariables(string key, string environmentPrefix, string argumentValue, string environmentValue) + { bool hasArgument = argumentValue != null; cakeArgumentsMock.Setup(x => x.HasArgument(key)).Returns(hasArgument); - if (hasArgument) { + if (hasArgument) + { cakeArgumentsMock.Setup(x => x.GetArgument(key)).Returns(argumentValue.ToString()); } bool hasEnvironmentVariable = environmentValue != null; @@ -31,8 +35,9 @@ namespace Cake.ArgumentHelpers.Tests { } } - [Test] - public void SomeArgumentAndNullEnvironment_ReturnsSome() { + [Fact] + public void SomeArgumentAndNullEnvironment_ReturnsSome() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; string testArgumentValue = "Some"; @@ -43,10 +48,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = testArgumentValue; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, (string)null); - Assert.AreEqual(expected, actual, "Didn't find Argument variable."); + Assert.Equal(expected, actual); } - [Test] - public void NullArgumentAndNullEnvironmentAndNullDefault_ReturnsNull() { + [Fact] + public void NullArgumentAndNullEnvironmentAndNullDefault_ReturnsNull() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; string testArgumentValue = null; @@ -57,10 +63,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = (string)null; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, (string)null); - Assert.AreEqual(expected, actual, "Found unexpected variable value."); + Assert.Equal(expected, actual); } - [Test] - public void NullArgumentAndSomeEnvironment_ReturnsSome() { + [Fact] + public void NullArgumentAndSomeEnvironment_ReturnsSome() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; string testArgumentValue = null; @@ -71,10 +78,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = testEnvironmentValue; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, (string)null); - Assert.AreEqual(expected, actual, "Didn't find Environment variable."); + Assert.Equal(expected, actual); } - [Test] - public void NullArgumentAndSomeEnvironmentWithoutPrefix_ReturnsSome() { + [Fact] + public void NullArgumentAndSomeEnvironmentWithoutPrefix_ReturnsSome() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = (string)null; string testArgumentValue = null; @@ -85,10 +93,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = testEnvironmentValue; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, (string)null); - Assert.AreEqual(expected, actual, "Didn't find Environment variable without prefix."); + Assert.Equal(expected, actual); } - [Test] - public void SomeArgumentAndOtherEnvironment_ReturnsSome() { + [Fact] + public void SomeArgumentAndOtherEnvironment_ReturnsSome() + { var testKey = "someVariable"; var testKeyEnvironmentPrefix = "somePrefix_"; string testArgumentValue = "Some"; @@ -99,9 +108,9 @@ namespace Cake.ArgumentHelpers.Tests { var expected = testArgumentValue; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, (string)null); - Assert.AreEqual(expected, actual, "Didn't find correct variable value from Argument source."); + Assert.Equal(expected, actual); } - [Test] + [Fact] public void NullArgumentAndNullEnvironment_ReturnsDefault() { var testKey = "someVariable"; @@ -115,9 +124,9 @@ namespace Cake.ArgumentHelpers.Tests { var expected = defaultValue; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix, defaultValue); - Assert.AreEqual(expected, actual, "Didn't fall back on default value."); + Assert.Equal(expected, actual); } - [Test] + [Fact] public void NullArgumentAndNullEnvironmentWithoutDefault_ReturnsNull() { var testKey = "someVariable"; @@ -130,7 +139,11 @@ namespace Cake.ArgumentHelpers.Tests { var expected = (string)null; var actual = cakeContextMock.Object.ArgumentOrEnvironmentVariable(testKey, testKeyEnvironmentPrefix); - Assert.AreEqual(expected, actual, "Didn't fail to a null value."); + Assert.Equal(expected, actual); + } + + public void Dispose() + { } } } diff --git a/Cake.ArgumentHelpers.Tests/Cake.ArgumentHelpers.Tests.csproj b/Cake.ArgumentHelpers.Tests/Cake.ArgumentHelpers.Tests.csproj index bbce4f6..8a52ac0 100644 --- a/Cake.ArgumentHelpers.Tests/Cake.ArgumentHelpers.Tests.csproj +++ b/Cake.ArgumentHelpers.Tests/Cake.ArgumentHelpers.Tests.csproj @@ -1,62 +1,33 @@  - + - Debug - AnyCPU - {1297E243-9A95-45A5-A5C6-AAAC94ECEE22} - Library - Cake.ArgumentHelpers.Tests Cake.ArgumentHelpers.Tests - v4.6.1 - - - true - full - false - bin\Debug - DEBUG; - prompt - 4 - - - true - bin\Release - prompt - 4 + net461;netcoreapp2.0 + true + true + + + + + + + + + + + + + + + + - - ..\packages\NUnit.3.7.1\lib\net45\nunit.framework.dll - - - ..\packages\Cake.Core.0.21.0\lib\net45\Cake.Core.dll - - - ..\packages\Cake.Common.0.21.0\lib\net45\Cake.Common.dll - - - ..\packages\Castle.Core.4.1.0\lib\net45\Castle.Core.dll - - - ..\packages\Moq.4.7.63\lib\net45\Moq.dll - + + - - + - - - - - - {9C50A7C4-E00D-4851-8311-81135D062C77} - Cake.ArgumentHelpers - - - - - - \ No newline at end of file diff --git a/Cake.ArgumentHelpers.Tests/packages.config b/Cake.ArgumentHelpers.Tests/packages.config deleted file mode 100644 index 40b370e..0000000 --- a/Cake.ArgumentHelpers.Tests/packages.config +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/Cake.ArgumentHelpers/ArgumentOrEnvironmentVariableAlias.cs b/Cake.ArgumentHelpers/ArgumentOrEnvironmentVariableAlias.cs index a09554f..39e3c32 100644 --- a/Cake.ArgumentHelpers/ArgumentOrEnvironmentVariableAlias.cs +++ b/Cake.ArgumentHelpers/ArgumentOrEnvironmentVariableAlias.cs @@ -1,53 +1,63 @@ using System; +using Cake.Common; using Cake.Core; using Cake.Core.Annotations; -using Cake.Common; -namespace Cake.ArgumentHelpers { +namespace Cake.ArgumentHelpers +{ /// /// Contains Aliases for helping work with combinations of Argument and Environment variables. /// [CakeAliasCategory("Arguments")] [CakeAliasCategory("Environment")] - public static class ArgumentOrEnvironmentVariableAlias { + public static class ArgumentOrEnvironmentVariableAlias + { /// /// Get a bool variable from various script inputs: first via Argument, then falling back on EnvironmentVariable, finally falling back on a default. /// + /// Cake context /// The argument name to attempt to find in the command line parameters, prefixing with to attempt to find in environment variables. /// An optional prefix used to qualify the same variable name when present in EnvironmentVariable form (e.g., "MySetting" command-line argument vs. "MyTool_MySetting" environment variable). + /// The default value /// Value found or default, first checked in command-line argument, then environment variable. [CakeMethodAlias] [CakeAliasCategory("Argument or environment variable")] - public static bool ArgumentOrEnvironmentVariable(this ICakeContext context, string name, string environmentNamePrefix, bool defaultValue) { - return ArgumentAliases.Argument(context, name, EnvironmentAliases.EnvironmentVariable(context, (environmentNamePrefix ?? "") + name) ?? defaultValue.ToString()).Equals("true", StringComparison.OrdinalIgnoreCase); - } + public static bool ArgumentOrEnvironmentVariable(this ICakeContext context, string name, string environmentNamePrefix, bool defaultValue) => + ArgumentAliases.Argument(context, name, EnvironmentAliases.EnvironmentVariable(context, (environmentNamePrefix ?? string.Empty) + name) ?? defaultValue.ToString()).Equals("true", StringComparison.OrdinalIgnoreCase); /// /// Get a bool variable from various script inputs: first via Argument, then falling back on EnvironmentVariable, finally falling back on a default. /// + /// Cake context /// The argument name to attempt to find in either the command line parameters or environment variables. + /// The default value /// Value found or default, first checked in command-line argument, then environment variable. [CakeMethodAlias] [CakeAliasCategory("Argument or environment variable")] - public static bool ArgumentOrEnvironmentVariable(this ICakeContext context, string name, bool defaultValue) { + public static bool ArgumentOrEnvironmentVariable(this ICakeContext context, string name, bool defaultValue) + { return context.ArgumentOrEnvironmentVariable(name, null, defaultValue); } /// /// Get a string variable from various script inputs: first via Argument, then falling back on EnvironmentVariable, finally falling back on a default. /// + /// Cake context /// The argument name to attempt to find in the command line parameters, prefixing with to attempt to find in environment variables. /// An optional prefix used to qualify the same variable name when present in EnvironmentVariable form (e.g., "MySetting" command-line argument vs. "MyTool_MySetting" environment variable). + /// The default value /// Value found or default, first checked in command-line argument, then environment variable. [CakeMethodAlias] [CakeAliasCategory("Argument or environment variable")] - public static string ArgumentOrEnvironmentVariable(this ICakeContext context, string name, string environmentNamePrefix, string defaultValue) { + public static string ArgumentOrEnvironmentVariable(this ICakeContext context, string name, string environmentNamePrefix, string defaultValue) + { return ArgumentAliases.Argument(context, name, EnvironmentAliases.EnvironmentVariable(context, environmentNamePrefix + name)) ?? defaultValue; } /// /// Get a string variable from various script inputs: first via Argument, then falling back on EnvironmentVariable, finally falling back on a default. /// + /// Cake context /// The argument name to attempt to find in the command line parameters, prefixing with to attempt to find in environment variables. /// An optional prefix used to qualify the same variable name when present in EnvironmentVariable form (e.g., "MySetting" command-line argument vs. "MyTool_MySetting" environment variable). /// Value found or default, first checked in command-line argument, then environment variable. diff --git a/Cake.ArgumentHelpers/Cake.ArgumentHelpers.csproj b/Cake.ArgumentHelpers/Cake.ArgumentHelpers.csproj index 5eeae28..c5448be 100644 --- a/Cake.ArgumentHelpers/Cake.ArgumentHelpers.csproj +++ b/Cake.ArgumentHelpers/Cake.ArgumentHelpers.csproj @@ -1,58 +1,34 @@  - - - - Debug - AnyCPU - {9C50A7C4-E00D-4851-8311-81135D062C77} - Library - Properties - Cake.ArgumentHelpers - Cake.ArgumentHelpers - v4.5 - 512 - - - - true - full - false - bin\Debug\ - DEBUG;TRACE - prompt - 4 - - - pdbonly - true - bin\Release\ - TRACE - prompt - 4 - bin\Release\Cake.ArgumentHelpers.xml - - - - - - - - - - - - ..\packages\Cake.Core.0.21.0\lib\net45\Cake.Core.dll - - - ..\packages\Cake.Common.0.21.0\lib\net45\Cake.Common.dll - - - - - - - - - - + + + Cake.ArgumentHelpers + net46;netstandard2.0 + Library + AnyCpu + true + + + + Cake aliases (methods) to help with consuming arguments and environment variables. + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Cake.ArgumentHelpers/Properties/AssemblyInfo.cs b/Cake.ArgumentHelpers/Properties/AssemblyInfo.cs index af5f76e..ab726bb 100644 --- a/Cake.ArgumentHelpers/Properties/AssemblyInfo.cs +++ b/Cake.ArgumentHelpers/Properties/AssemblyInfo.cs @@ -7,8 +7,6 @@ using System.Runtime.InteropServices; // associated with an assembly. [assembly: AssemblyTitle("Cake.ArgumentHelpers")] [assembly: AssemblyDescription("")] -[assembly: AssemblyConfiguration("")] -[assembly: AssemblyCompany("")] [assembly: AssemblyProduct("Cake.ArgumentHelpers")] [assembly: AssemblyCopyright("Copyright 2017 © Adam Patridge")] [assembly: AssemblyTrademark("")] diff --git a/Cake.ArgumentHelpers/packages.config b/Cake.ArgumentHelpers/packages.config deleted file mode 100644 index 6f24d92..0000000 --- a/Cake.ArgumentHelpers/packages.config +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/Cake.ruleset b/Cake.ruleset new file mode 100644 index 0000000..47e31ae --- /dev/null +++ b/Cake.ruleset @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Shared.msbuild b/Shared.msbuild new file mode 100644 index 0000000..f30826d --- /dev/null +++ b/Shared.msbuild @@ -0,0 +1,57 @@ + + + + $(AssemblyName) + Copyright (c) .NET Foundation and contributors + Patrik Svensson, Mattias Karlsson, Gary Ewan Park, Alistair Chapman, Martin Björkström and contributors + Patrik Svensson, Mattias Karlsson, Gary Ewan Park, Alistair Chapman, Martin Björkström and contributors + https://github.com/cake-build/cake/blob/develop/LICENSE + https://raw.githubusercontent.com/cake-build/graphics/master/png/cake-medium.png + https://github.com/cake-build/cake + git + Cake;Script;Build + + + + 2.0.0 + + + + true + + + + $(DefineConstants);NETCORE + portable + + + $(DefineConstants);NETCORE + portable + + + + false + false + false + false + false + false + false + + + + $(MSBuildThisFileDirectory)Cake.ruleset + $(MSBuildThisFileDirectory)Test.ruleset + + + + PreserveNewest + + + + + + All + + + diff --git a/Test.ruleset b/Test.ruleset new file mode 100644 index 0000000..9e5e3c9 --- /dev/null +++ b/Test.ruleset @@ -0,0 +1,49 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/stylecop.json b/stylecop.json new file mode 100644 index 0000000..a256a29 --- /dev/null +++ b/stylecop.json @@ -0,0 +1,32 @@ +{ + "$schema": "https://raw.githubusercontent.com/DotNetAnalyzers/StyleCopAnalyzers/master/StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json", + "settings": { + "indentation": { + "useTabs": false, + "indentationSize": 4 + }, + "documentationRules": { + "documentExposedElements": true, + "documentInternalElements": false, + "documentPrivateElements": false, + "documentInterfaces": true, + "documentPrivateFields": false + }, + "layoutRules": { + "newlineAtEndOfFile": "allow" + }, + "maintainabilityRules": { + }, + "orderingRules": { + "usingDirectivesPlacement": "outsideNamespace", + "systemUsingDirectivesFirst": true, + "elementOrder": [ + "kind", + "accessibility", + "constant", + "static", + "readonly" + ] + } + } +} diff --git a/xunit.runner.json b/xunit.runner.json new file mode 100644 index 0000000..4fb88b5 --- /dev/null +++ b/xunit.runner.json @@ -0,0 +1 @@ +{ "appDomain": "denied" }