unify SMAPI.AssemblyRewriters and SMAPI.Common projects

8 files changed, 536 insertions, 0 deletions

diff --git a/src/SMAPI.Internal/EnvironmentUtility.cs b/src/SMAPI.Internal/EnvironmentUtility.cs
new file mode 100644
index 00000000..a3581898
--- /dev/null
+++ b/src/SMAPI.Internal/EnvironmentUtility.cs
@@ -0,0 +1,112 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+#if SMAPI_FOR_WINDOWS
+using System.Management;
+#endif
+using System.Runtime.InteropServices;
+
+namespace StardewModdingAPI.Internal
+{
+    /// <summary>Provides methods for fetching environment information.</summary>
+    internal static class EnvironmentUtility
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>Get the OS name from the system uname command.</summary>
+        /// <param name="buffer">The buffer to fill with the resulting string.</param>
+        [DllImport("libc")]
+        static extern int uname(IntPtr buffer);
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Detect the current OS.</summary>
+        public static Platform DetectPlatform()
+        {
+            switch (Environment.OSVersion.Platform)
+            {
+                case PlatformID.MacOSX:
+                    return Platform.Mac;
+
+                case PlatformID.Unix:
+                    return EnvironmentUtility.IsRunningMac()
+                        ? Platform.Mac
+                        : Platform.Linux;
+
+                default:
+                    return Platform.Windows;
+            }
+        }
+
+        
+        /// <summary>Get the human-readable OS name and version.</summary>
+        /// <param name="platform">The current platform.</param>
+        [SuppressMessage("ReSharper", "EmptyGeneralCatchClause", Justification = "Error suppressed deliberately to fallback to default behaviour.")]
+        public static string GetFriendlyPlatformName(Platform platform)
+        {
+#if SMAPI_FOR_WINDOWS
+            try
+            {
+                return new ManagementObjectSearcher("SELECT Caption FROM Win32_OperatingSystem")
+                    .Get()
+                    .Cast<ManagementObject>()
+                    .Select(entry => entry.GetPropertyValue("Caption").ToString())
+                    .FirstOrDefault();
+            }
+            catch { }
+#endif
+            return (platform == Platform.Mac ? "MacOS " : "") + Environment.OSVersion;
+        }
+
+        /// <summary>Get the name of the Stardew Valley executable.</summary>
+        /// <param name="platform">The current platform.</param>
+        public static string GetExecutableName(Platform platform)
+        {
+            return platform == Platform.Windows
+                ? "Stardew Valley.exe"
+                : "StardewValley.exe";
+        }
+
+        /// <summary>Get whether the platform uses Mono.</summary>
+        /// <param name="platform">The current platform.</param>
+        public static bool IsMono(this Platform platform)
+        {
+            return platform == Platform.Linux || platform == Platform.Mac;
+        }
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>Detect whether the code is running on Mac.</summary>
+        /// <remarks>
+        /// This code is derived from the Mono project (see System.Windows.Forms/System.Windows.Forms/XplatUI.cs). It detects Mac by calling the
+        /// <c>uname</c> system command and checking the response, which is always 'Darwin' for MacOS.
+        /// </remarks>
+        private static bool IsRunningMac()
+        {
+            IntPtr buffer = IntPtr.Zero;
+            try
+            {
+                buffer = Marshal.AllocHGlobal(8192);
+                if (EnvironmentUtility.uname(buffer) == 0)
+                {
+                    string os = Marshal.PtrToStringAnsi(buffer);
+                    return os == "Darwin";
+                }
+                return false;
+            }
+            catch
+            {
+                return false; // default to Linux
+            }
+            finally
+            {
+                if (buffer != IntPtr.Zero)
+                    Marshal.FreeHGlobal(buffer);
+            }
+        }
+    }
+}
diff --git a/src/SMAPI.Internal/Models/ModInfoModel.cs b/src/SMAPI.Internal/Models/ModInfoModel.cs
new file mode 100644
index 00000000..725c88bb
--- /dev/null
+++ b/src/SMAPI.Internal/Models/ModInfoModel.cs
@@ -0,0 +1,56 @@
+namespace StardewModdingAPI.Internal.Models
+{
+    /// <summary>Generic metadata about a mod.</summary>
+    internal class ModInfoModel
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>The mod name.</summary>
+        public string Name { get; set; }
+
+        /// <summary>The semantic version for the mod's latest release.</summary>
+        public string Version { get; set; }
+
+        /// <summary>The semantic version for the mod's latest preview release, if available and different from <see cref="Version"/>.</summary>
+        public string PreviewVersion { get; set; }
+
+        /// <summary>The mod's web URL.</summary>
+        public string Url { get; set; }
+
+        /// <summary>The error message indicating why the mod is invalid (if applicable).</summary>
+        public string Error { get; set; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an empty instance.</summary>
+        public ModInfoModel()
+        {
+            // needed for JSON deserialising
+        }
+
+        /// <summary>Construct an instance.</summary>
+        /// <param name="name">The mod name.</param>
+        /// <param name="version">The semantic version for the mod's latest release.</param>
+        /// <param name="previewVersion">The semantic version for the mod's latest preview release, if available and different from <see cref="Version"/>.</param>
+        /// <param name="url">The mod's web URL.</param>
+        /// <param name="error">The error message indicating why the mod is invalid (if applicable).</param>
+        public ModInfoModel(string name, string version, string url, string previewVersion = null, string error = null)
+        {
+            this.Name = name;
+            this.Version = version;
+            this.PreviewVersion = previewVersion;
+            this.Url = url;
+            this.Error = error; // mainly initialised here for the JSON deserialiser
+        }
+
+        /// <summary>Construct an instance.</summary>
+        /// <param name="error">The error message indicating why the mod is invalid.</param>
+        public ModInfoModel(string error)
+        {
+            this.Error = error;
+        }
+    }
+}
diff --git a/src/SMAPI.Internal/Models/ModSeachModel.cs b/src/SMAPI.Internal/Models/ModSeachModel.cs
new file mode 100644
index 00000000..fac72135
--- /dev/null
+++ b/src/SMAPI.Internal/Models/ModSeachModel.cs
@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace StardewModdingAPI.Internal.Models
+{
+    /// <summary>Specifies mods whose update-check info to fetch.</summary>
+    internal class ModSearchModel
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>The namespaced mod keys to search.</summary>
+        public string[] ModKeys { get; set; }
+
+        /// <summary>Whether to allow non-semantic versions, instead of returning an error for those.</summary>
+        public bool AllowInvalidVersions { get; set; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an empty instance.</summary>
+        public ModSearchModel()
+        {
+            // needed for JSON deserialising
+        }
+
+        /// <summary>Construct an instance.</summary>
+        /// <param name="modKeys">The namespaced mod keys to search.</param>
+        /// <param name="allowInvalidVersions">Whether to allow non-semantic versions, instead of returning an error for those.</param>
+        public ModSearchModel(IEnumerable<string> modKeys, bool allowInvalidVersions)
+        {
+            this.ModKeys = modKeys.ToArray();
+            this.AllowInvalidVersions = allowInvalidVersions;
+        }
+    }
+}
diff --git a/src/SMAPI.Internal/Platform.cs b/src/SMAPI.Internal/Platform.cs
new file mode 100644
index 00000000..81ca5c1f
--- /dev/null
+++ b/src/SMAPI.Internal/Platform.cs
@@ -0,0 +1,15 @@
+namespace StardewModdingAPI.Internal
+{
+    /// <summary>The game's platform version.</summary>
+    internal enum Platform
+    {
+        /// <summary>The Linux version of the game.</summary>
+        Linux,
+
+        /// <summary>The Mac version of the game.</summary>
+        Mac,
+
+        /// <summary>The Windows version of the game.</summary>
+        Windows
+    }
+}
diff --git a/src/SMAPI.Internal/Properties/AssemblyInfo.cs b/src/SMAPI.Internal/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..b314b353
--- /dev/null
+++ b/src/SMAPI.Internal/Properties/AssemblyInfo.cs
@@ -0,0 +1,9 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: AssemblyTitle("SMAPI.Internal")]
+[assembly: AssemblyDescription("Contains internal SMAPI code that's shared between its projects.")]
+[assembly: InternalsVisibleTo("StardewModdingAPI")]
+[assembly: InternalsVisibleTo("StardewModdingAPI.ModBuildConfig")]
+[assembly: InternalsVisibleTo("StardewModdingAPI.Installer")]
+[assembly: InternalsVisibleTo("StardewModdingAPI.Web")]
diff --git a/src/SMAPI.Internal/RewriteFacades/SpriteBatchMethods.cs b/src/SMAPI.Internal/RewriteFacades/SpriteBatchMethods.cs
new file mode 100644
index 00000000..5e5d117e
--- /dev/null
+++ b/src/SMAPI.Internal/RewriteFacades/SpriteBatchMethods.cs
@@ -0,0 +1,59 @@
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace StardewModdingAPI.Internal.RewriteFacades
+{
+    /// <summary>Provides <see cref="SpriteBatch"/> method signatures that can be injected into mod code for compatibility between Linux/Mac or Windows.</summary>
+    public class SpriteBatchMethods : SpriteBatch
+    {
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        public SpriteBatchMethods(GraphicsDevice graphicsDevice) : base(graphicsDevice) { }
+
+
+        /****
+        ** MonoGame signatures
+        ****/
+        [SuppressMessage("ReSharper", "CS0109", Justification = "The 'new' modifier applies when compiled on Linux/Mac.")]
+        public new void Begin(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState, DepthStencilState depthStencilState, RasterizerState rasterizerState, Effect effect, Matrix? matrix)
+        {
+            base.Begin(sortMode, blendState, samplerState, depthStencilState, rasterizerState, effect, matrix ?? Matrix.Identity);
+        }
+
+        /****
+        ** XNA signatures
+        ****/
+        [SuppressMessage("ReSharper", "CS0109", Justification = "The 'new' modifier applies when compiled on Windows.")]
+        public new void Begin()
+        {
+            base.Begin();
+        }
+
+        [SuppressMessage("ReSharper", "CS0109", Justification = "The 'new' modifier applies when compiled on Windows.")]
+        public new void Begin(SpriteSortMode sortMode, BlendState blendState)
+        {
+            base.Begin(sortMode, blendState);
+        }
+
+        [SuppressMessage("ReSharper", "CS0109", Justification = "The 'new' modifier applies when compiled on Windows.")]
+        public new void Begin(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState, DepthStencilState depthStencilState, RasterizerState rasterizerState)
+        {
+            base.Begin(sortMode, blendState, samplerState, depthStencilState, rasterizerState);
+        }
+
+        [SuppressMessage("ReSharper", "CS0109", Justification = "The 'new' modifier applies when compiled on Windows.")]
+        public new void Begin(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState, DepthStencilState depthStencilState, RasterizerState rasterizerState, Effect effect)
+        {
+            base.Begin(sortMode, blendState, samplerState, depthStencilState, rasterizerState, effect);
+        }
+
+        [SuppressMessage("ReSharper", "CS0109", Justification = "The 'new' modifier applies when compiled on Windows.")]
+        public new void Begin(SpriteSortMode sortMode, BlendState blendState, SamplerState samplerState, DepthStencilState depthStencilState, RasterizerState rasterizerState, Effect effect, Matrix transformMatrix)
+        {
+            base.Begin(sortMode, blendState, samplerState, depthStencilState, rasterizerState, effect, transformMatrix);
+        }
+    }
+}
diff --git a/src/SMAPI.Internal/SemanticVersionImpl.cs b/src/SMAPI.Internal/SemanticVersionImpl.cs
new file mode 100644
index 00000000..6da16336
--- /dev/null
+++ b/src/SMAPI.Internal/SemanticVersionImpl.cs
@@ -0,0 +1,199 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace StardewModdingAPI.Internal
+{
+    /// <summary>A low-level implementation of a semantic version with an optional release tag.</summary>
+    /// <remarks>The implementation is defined by Semantic Version 2.0 (http://semver.org/).</remarks>
+    internal class SemanticVersionImpl
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>The major version incremented for major API changes.</summary>
+        public int Major { get; }
+
+        /// <summary>The minor version incremented for backwards-compatible changes.</summary>
+        public int Minor { get; }
+
+        /// <summary>The patch version for backwards-compatible bug fixes.</summary>
+        public int Patch { get; }
+
+        /// <summary>An optional prerelease tag.</summary>
+        public string Tag { get; }
+
+        /// <summary>A regex pattern matching a version within a larger string.</summary>
+        internal const string UnboundedVersionPattern = @"(?>(?<major>0|[1-9]\d*))\.(?>(?<minor>0|[1-9]\d*))(?>(?:\.(?<patch>0|[1-9]\d*))?)(?:-(?<prerelease>(?>[a-z0-9]+[\-\.]?)+))?";
+
+        /// <summary>A regular expression matching a semantic version string.</summary>
+        /// <remarks>
+        /// This pattern is derived from the BNF documentation in the <a href="https://github.com/mojombo/semver">semver repo</a>,
+        /// with three important deviations intended to support Stardew Valley mod conventions:
+        /// - allows short-form "x.y" versions;
+        /// - allows hyphens in prerelease tags as synonyms for dots (like "-unofficial-update.3");
+        /// - doesn't allow '+build' suffixes.
+        /// </remarks>
+        internal static readonly Regex Regex = new Regex($@"^{SemanticVersionImpl.UnboundedVersionPattern}$", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.ExplicitCapture);
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="major">The major version incremented for major API changes.</param>
+        /// <param name="minor">The minor version incremented for backwards-compatible changes.</param>
+        /// <param name="patch">The patch version for backwards-compatible bug fixes.</param>
+        /// <param name="tag">An optional prerelease tag.</param>
+        public SemanticVersionImpl(int major, int minor, int patch, string tag = null)
+        {
+            this.Major = major;
+            this.Minor = minor;
+            this.Patch = patch;
+            this.Tag = this.GetNormalisedTag(tag);
+        }
+
+        /// <summary>Construct an instance.</summary>
+        /// <param name="version">The assembly version.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="version"/> is null.</exception>
+        public SemanticVersionImpl(Version version)
+        {
+            if (version == null)
+                throw new ArgumentNullException(nameof(version), "The input version can't be null.");
+
+            this.Major = version.Major;
+            this.Minor = version.Minor;
+            this.Patch = version.Build;
+        }
+
+        /// <summary>Construct an instance.</summary>
+        /// <param name="version">The semantic version string.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="version"/> is null.</exception>
+        /// <exception cref="FormatException">The <paramref name="version"/> is not a valid semantic version.</exception>
+        public SemanticVersionImpl(string version)
+        {
+            // parse
+            if (version == null)
+                throw new ArgumentNullException(nameof(version), "The input version string can't be null.");
+            var match = SemanticVersionImpl.Regex.Match(version.Trim());
+            if (!match.Success)
+                throw new FormatException($"The input '{version}' isn't a valid semantic version.");
+
+            // initialise
+            this.Major = int.Parse(match.Groups["major"].Value);
+            this.Minor = match.Groups["minor"].Success ? int.Parse(match.Groups["minor"].Value) : 0;
+            this.Patch = match.Groups["patch"].Success ? int.Parse(match.Groups["patch"].Value) : 0;
+            this.Tag = match.Groups["prerelease"].Success ? this.GetNormalisedTag(match.Groups["prerelease"].Value) : null;
+        }
+
+        /// <summary>Get an integer indicating whether this version precedes (less than 0), supercedes (more than 0), or is equivalent to (0) the specified version.</summary>
+        /// <param name="other">The version to compare with this instance.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="other"/> value is null.</exception>
+        public int CompareTo(SemanticVersionImpl other)
+        {
+            if (other == null)
+                throw new ArgumentNullException(nameof(other));
+            return this.CompareTo(other.Major, other.Minor, other.Patch, other.Tag);
+        }
+
+
+        /// <summary>Get an integer indicating whether this version precedes (less than 0), supercedes (more than 0), or is equivalent to (0) the specified version.</summary>
+        /// <param name="otherMajor">The major version to compare with this instance.</param>
+        /// <param name="otherMinor">The minor version to compare with this instance.</param>
+        /// <param name="otherPatch">The patch version to compare with this instance.</param>
+        /// <param name="otherTag">The prerelease tag to compare with this instance.</param>
+        public int CompareTo(int otherMajor, int otherMinor, int otherPatch, string otherTag)
+        {
+            const int same = 0;
+            const int curNewer = 1;
+            const int curOlder = -1;
+
+            // compare stable versions
+            if (this.Major != otherMajor)
+                return this.Major.CompareTo(otherMajor);
+            if (this.Minor != otherMinor)
+                return this.Minor.CompareTo(otherMinor);
+            if (this.Patch != otherPatch)
+                return this.Patch.CompareTo(otherPatch);
+            if (this.Tag == otherTag)
+                return same;
+
+            // stable supercedes pre-release
+            bool curIsStable = string.IsNullOrWhiteSpace(this.Tag);
+            bool otherIsStable = string.IsNullOrWhiteSpace(otherTag);
+            if (curIsStable)
+                return curNewer;
+            if (otherIsStable)
+                return curOlder;
+
+            // compare two pre-release tag values
+            string[] curParts = this.Tag.Split('.', '-');
+            string[] otherParts = otherTag.Split('.', '-');
+            for (int i = 0; i < curParts.Length; i++)
+            {
+                // longer prerelease tag supercedes if otherwise equal
+                if (otherParts.Length <= i)
+                    return curNewer;
+
+                // compare if different
+                if (curParts[i] != otherParts[i])
+                {
+                    // compare numerically if possible
+                    {
+                        if (int.TryParse(curParts[i], out int curNum) && int.TryParse(otherParts[i], out int otherNum))
+                            return curNum.CompareTo(otherNum);
+                    }
+
+                    // else compare lexically
+                    return string.Compare(curParts[i], otherParts[i], StringComparison.OrdinalIgnoreCase);
+                }
+            }
+
+            // fallback (this should never happen)
+            return string.Compare(this.ToString(), new SemanticVersionImpl(otherMajor, otherMinor, otherPatch, otherTag).ToString(), StringComparison.InvariantCultureIgnoreCase);
+        }
+
+        /// <summary>Get a string representation of the version.</summary>
+        public override string ToString()
+        {
+            // version
+            string result = this.Patch != 0
+                ? $"{this.Major}.{this.Minor}.{this.Patch}"
+                : $"{this.Major}.{this.Minor}";
+
+            // tag
+            string tag = this.Tag;
+            if (tag != null)
+                result += $"-{tag}";
+            return result;
+        }
+
+        /// <summary>Parse a version string without throwing an exception if it fails.</summary>
+        /// <param name="version">The version string.</param>
+        /// <param name="parsed">The parsed representation.</param>
+        /// <returns>Returns whether parsing the version succeeded.</returns>
+        internal static bool TryParse(string version, out SemanticVersionImpl parsed)
+        {
+            try
+            {
+                parsed = new SemanticVersionImpl(version);
+                return true;
+            }
+            catch
+            {
+                parsed = null;
+                return false;
+            }
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>Get a normalised build tag.</summary>
+        /// <param name="tag">The tag to normalise.</param>
+        private string GetNormalisedTag(string tag)
+        {
+            tag = tag?.Trim();
+            return !string.IsNullOrWhiteSpace(tag) ? tag : null;
+        }
+    }
+}
diff --git a/src/SMAPI.Internal/StardewModdingAPI.Internal.csproj b/src/SMAPI.Internal/StardewModdingAPI.Internal.csproj
new file mode 100644
index 00000000..6e7fa368
--- /dev/null
+++ b/src/SMAPI.Internal/StardewModdingAPI.Internal.csproj
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
+    <ProjectGuid>{10DB0676-9FC1-4771-A2C8-E2519F091E49}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>StardewModdingAPI.Internal</RootNamespace>
+    <AssemblyName>StardewModdingAPI.Internal</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\..\build\GlobalAssemblyInfo.cs">
+      <Link>Properties\GlobalAssemblyInfo.cs</Link>
+    </Compile>
+    <Compile Include="EnvironmentUtility.cs" />
+    <Compile Include="Models\ModInfoModel.cs" />
+    <Compile Include="Models\ModSeachModel.cs" />
+    <Compile Include="Platform.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RewriteFacades\SpriteBatchMethods.cs" />
+    <Compile Include="SemanticVersionImpl.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Import Project="..\..\build\common.targets" />
+</Project>
\ No newline at end of file