Feature/unity version check

UnityEngineAnalyzer.CLI/AnalyzerReport.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using Microsoft.CodeAnalysis;
 using UnityEngineAnalyzer.CLI.Reporting;
 
@@ -52,10 +51,10 @@ public void AppendDiagnostics(IEnumerable<Diagnostic> diagnosticResults)
                     FileName = fileName,
                     LineNumber = lineNumber,
                     CharacterPosition = characterPosition,
-                    Severity = (DiagnosticInfo.DiagnosticInfoSeverity)diagnostic.Severity
+                    Severity = (DiagnosticInfo.DiagnosticInfoSeverity)diagnostic.Severity,
+                    VersionSpan = DiagnosticDescriptors.GetVersion(diagnostic.Descriptor)
                 };
 
-
                 foreach (var exporter in _exporters)
                 {
                     exporter.AppendDiagnostic(diagnosticInfo);
@@ -71,11 +70,11 @@ public void FinalizeReport(TimeSpan duration)
             }
         }
 
-        public void InitializeReport(FileInfo projectFile)
+        public void InitializeReport(Options options)
         {
             foreach (var exporter in _exporters)
             {
-                exporter.InitializeExporter(projectFile);       
+                exporter.InitializeExporter(options);
             }
         }
 

UnityEngineAnalyzer.CLI/Options.cs

@@ -1,10 +1,10 @@
 using CommandLine;
 using System.Collections.Generic;
-using UnityEngineAnalyzer.CLI.Reporting;
+using static UnityEngineAnalyzer.CLI.Reporting.DiagnosticInfo;
 
 namespace UnityEngineAnalyzer.CLI
 {
-    internal class Options
+    public class Options
     {
         [ValueOption(0)]
         public string ProjectFile { get; set; }
@@ -15,7 +15,10 @@ internal class Options
         [Option('c', "configuration", HelpText = "Custom json configuration to be used.")]
         public string ConfigurationFile { get; set; }
 
-        [Option('s', "severity", DefaultValue = DiagnosticInfo.DiagnosticInfoSeverity.Warning, HelpText = "Minimal severity to be reported.")]
-        public DiagnosticInfo.DiagnosticInfoSeverity MinimalSeverity { get; set; }
+        [Option('s', "severity", DefaultValue = DiagnosticInfoSeverity.Warning, HelpText = "Minimal severity to be reported.")]
+        public DiagnosticInfoSeverity MinimalSeverity { get; set; }
+
+        [Option('v', "version", DefaultValue = UnityVersion.NONE, HelpText = "Check against spesific Unity version.")]
+        public UnityVersion Version { get; set; }
     }
 }

UnityEngineAnalyzer.CLI/Program.cs

@@ -29,6 +29,9 @@ public static void Main(string[] args)
                     return;
                 }
 
+                var unityVersionResolver = new UnityVersionResolver();
+                options.Version = unityVersionResolver.ResolveVersion(options);
+
                 var startTime = DateTime.Now;
 
                 var fileName = options.ProjectFile;
@@ -52,11 +55,11 @@ public static void Main(string[] args)
                 if (report.GetExporterCount() == 0)
                 { 
                     //It's generally a good idea to make sure that the Console Exporter is last since it is interactive
-                    report.AddExporter(new JsonAnalyzerExporter(options.MinimalSeverity));
-                    report.AddExporter(new ConsoleAnalyzerExporter(options.MinimalSeverity));
+                    report.AddExporter(new JsonAnalyzerExporter(options));
+                    report.AddExporter(new ConsoleAnalyzerExporter(options));
                 }
 
-                report.InitializeReport(fileInfo);
+                report.InitializeReport(options);
 
                 var tasks = new List<Task>();
                 if (fileInfo.Exists)
@@ -89,6 +92,7 @@ public static void Main(string[] args)
             }
         }
 
+        //TODO SET TO OWN CLASS
 
     }
 }

UnityEngineAnalyzer.CLI/Reporting/AnalyzerExporter.cs

@@ -1,21 +1,34 @@
 using System;
-using System.IO;
 
 namespace UnityEngineAnalyzer.CLI.Reporting
 {
     public abstract class AnalyzerExporter : IAnalyzerExporter
     {
-        //NOTE: Can we use using.static.DiagnosticsInfo; C#6 feature?
-        protected DiagnosticInfo.DiagnosticInfoSeverity MinimalSeverity;
+        private readonly Options options;
 
-        public AnalyzerExporter(DiagnosticInfo.DiagnosticInfoSeverity MinimalSeverity)
+        public AnalyzerExporter(Options options)
         {
-            this.MinimalSeverity = MinimalSeverity;
+            this.options = options;
+        }
+
+        public bool IsAnalyzerRelevant(DiagnosticInfo diagnosticInfo)
+        {
+            if (options.MinimalSeverity > diagnosticInfo.Severity)
+            {
+                return false;
+            }
+
+            if (options.Version < diagnosticInfo.VersionSpan.First || options.Version > diagnosticInfo.VersionSpan.Last)
+            {
+                return false;
+            }
+
+            return true;
         }
 
         public abstract void AppendDiagnostic(DiagnosticInfo diagnosticInfo);
         public abstract void FinalizeExporter(TimeSpan duration);
-        public abstract void InitializeExporter(FileInfo projectFile);
+        public abstract void InitializeExporter(Options options);
         public abstract void NotifyException(Exception exception);
     }
 }

UnityEngineAnalyzer.CLI/Reporting/ConsoleAnalyzerExporter.cs

@@ -1,11 +1,10 @@
 using System;
-using System.IO;
 
 namespace UnityEngineAnalyzer.CLI.Reporting
 {
     public class ConsoleAnalyzerExporter : StandardOutputAnalyzerReporter
     {
-        public ConsoleAnalyzerExporter(DiagnosticInfo.DiagnosticInfoSeverity MinimalSeverity) : base(MinimalSeverity)
+        public ConsoleAnalyzerExporter(Options options) : base(options)
         {
         }
 
@@ -19,12 +18,13 @@ public override void FinalizeExporter(TimeSpan duration)
             Console.ReadKey();
         }
 
-        public override void InitializeExporter(FileInfo projectFile)
+        public override void InitializeExporter(Options options)
         {
             Console.ForegroundColor = ConsoleColor.Green;
             Console.WriteLine("Unity Syntax Analyzer");
             Console.WriteLine();
-            Console.WriteLine("Analyzing: {0}", projectFile.FullName);
+            Console.WriteLine("Analyzing: {0}", options.ProjectFile);
+            Console.WriteLine("With Unity version: " + Enum.GetName((typeof(UnityVersion)), options.Version));
             Console.WriteLine();
             Console.ResetColor();
         }

UnityEngineAnalyzer.CLI/Reporting/DiagnosticInfo.cs

@@ -10,6 +10,7 @@ public class DiagnosticInfo
         public int LineNumber { get; set; }
         public int CharacterPosition { get; set; }
         public DiagnosticInfoSeverity Severity { get; set; }
+        public UnityVersionSpan VersionSpan { get; set; }
 
         public enum DiagnosticInfoSeverity
         {

UnityEngineAnalyzer.CLI/Reporting/IAnalyzerExporter.cs

@@ -7,7 +7,7 @@ public interface IAnalyzerExporter
     {
         void AppendDiagnostic(DiagnosticInfo diagnosticInfo);
         void FinalizeExporter(TimeSpan duration);
-        void InitializeExporter(FileInfo projectFile);
+        void InitializeExporter(Options options);
         void NotifyException(Exception exception);
     }
 }

UnityEngineAnalyzer.CLI/Reporting/JsonAnalyzerExporter.cs

@@ -15,13 +15,13 @@ public class JsonAnalyzerExporter : AnalyzerExporter
         private readonly List<Exception> _exceptions = new List<Exception>();
         private string _destinationReportFile;
 
-        public JsonAnalyzerExporter(DiagnosticInfo.DiagnosticInfoSeverity MinimalSeverity) : base(MinimalSeverity)
+        public JsonAnalyzerExporter(Options options) : base(options)
         {
         }
 
         public override void AppendDiagnostic(DiagnosticInfo diagnosticInfo)
         {
-            if (diagnosticInfo.Severity >= MinimalSeverity)
+            if (IsAnalyzerRelevant(diagnosticInfo))
             {
                 _jsonSerializer.Serialize(_jsonWriter, diagnosticInfo);
             }
@@ -50,8 +50,9 @@ public override void FinalizeExporter(TimeSpan duration)
             //Process.Start(_destinationReportFile);
         }
 
-        public override void InitializeExporter(FileInfo projectFile)
+        public override void InitializeExporter(Options options)
         {
+            var projectFile = new FileInfo(options.ProjectFile);
             if (!projectFile.Exists)
             {
                 throw new ArgumentException("Project file does not exist");

UnityEngineAnalyzer.CLI/Reporting/StandardOutputAnalyzerReporter.cs

@@ -1,5 +1,5 @@
 using System;
-using System.IO;
+using static UnityEngineAnalyzer.CLI.Reporting.DiagnosticInfo;
 
 namespace UnityEngineAnalyzer.CLI.Reporting
 {
@@ -8,13 +8,13 @@ public class StandardOutputAnalyzerReporter : AnalyzerExporter
         protected const string ConsoleSeparator = "\t";
         protected const string FailurePrefix = "# ";
 
-        public StandardOutputAnalyzerReporter(DiagnosticInfo.DiagnosticInfoSeverity MinimalSeverity) : base(MinimalSeverity)
+        public StandardOutputAnalyzerReporter(Options options) : base(options)
         {
         }
 
         public override void AppendDiagnostic(DiagnosticInfo diagnosticInfo)
         {
-            if (diagnosticInfo.Severity < MinimalSeverity)
+            if (IsAnalyzerRelevant(diagnosticInfo) == false)
             {
                 return;
             }
@@ -30,20 +30,19 @@ public override void AppendDiagnostic(DiagnosticInfo diagnosticInfo)
             Console.Write(diagnosticInfo.Message);
             Console.ResetColor();
             Console.WriteLine(@"{0}{1}{0}{2},{3}", ConsoleSeparator,diagnosticInfo.FileName, diagnosticInfo.LineNumber, diagnosticInfo.CharacterPosition);
-
         }
 
-        private ConsoleColor ConsoleColorFromSeverity(DiagnosticInfo.DiagnosticInfoSeverity severity)
+        private ConsoleColor ConsoleColorFromSeverity(DiagnosticInfoSeverity severity)
         {
             switch (severity)
             {
-                case DiagnosticInfo.DiagnosticInfoSeverity.Hidden:
+                case DiagnosticInfoSeverity.Hidden:
                     return ConsoleColor.Gray;
-                case DiagnosticInfo.DiagnosticInfoSeverity.Info:
+                case DiagnosticInfoSeverity.Info:
                     return ConsoleColor.Green;
-                case DiagnosticInfo.DiagnosticInfoSeverity.Warning:
+                case DiagnosticInfoSeverity.Warning:
                     return ConsoleColor.Yellow;
-                case DiagnosticInfo.DiagnosticInfoSeverity.Error:
+                case DiagnosticInfoSeverity.Error:
                     return ConsoleColor.Red;
                 default:
                     return ConsoleColor.White;
@@ -71,7 +70,7 @@ public override void FinalizeExporter(TimeSpan duration)
         {
         }
 
-        public override void InitializeExporter(FileInfo projectFile)
+        public override void InitializeExporter(Options options)
         {
         }
     }

UnityEngineAnalyzer.CLI/UnityEngineAnalyzer.CLI.csproj

@@ -118,6 +118,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Reporting\StandardOutputAnalyzerReporter.cs" />
     <Compile Include="SolutionAnalyzer.cs" />
+    <Compile Include="UnityVersionResolver.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />

UnityEngineAnalyzer.CLI/UnityVersionResolver.cs

@@ -0,0 +1,65 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace UnityEngineAnalyzer.CLI
+{
+    //NOTE: This class would benefit from UnitTests specially: TryParseUnityVersion
+    internal class UnityVersionResolver
+    {
+        private const UnityVersion DEFAULT_UNITY_VERSION = UnityVersion.LATEST;
+
+        public UnityVersion ResolveVersion(Options options)
+        {
+            if (options.Version != UnityVersion.NONE)
+            {
+                return options.Version;
+            }
+
+            //THIS ONLY WORKS ON UNITY >= 5, before that ProjectVersion.txt did not exists
+            if (ResolveProjectVersionFilePath(options) != null)
+            {
+                var projectVersionString = File.ReadAllText(ResolveProjectVersionFilePath(options));
+                return TryParseUnityVersion(projectVersionString);
+            }
+
+            return DEFAULT_UNITY_VERSION;
+        }
+
+        private string ResolveProjectVersionFilePath(Options options)
+        {
+            var projectPath = new FileInfo(options.ProjectFile).Directory;
+            var path = Path.Combine(projectPath.FullName, "ProjectSettings", "ProjectVersion.txt");
+            var projectVersionFile = new FileInfo(path);
+
+            if (projectVersionFile.Exists)
+            {
+                return projectVersionFile.FullName;
+            }
+
+            return null;
+        }
+
+        private UnityVersion TryParseUnityVersion(string version)
+        {
+            string editorText = "m_EditorVersion: ";
+            var match = Regex.Match(version, editorText + "[0-9.a-z]*");
+
+            string src = match.Value.Substring(editorText.Length);
+            src = src.Replace('.', '_');
+            src = src.Substring(0, src.IndexOf('_') + 2);
+
+            var unityVersions = Enum.GetValues(typeof(UnityVersion)).Cast<UnityVersion>();
+            foreach (var unityVersion in unityVersions)
+            {
+                if (Enum.GetName(typeof(UnityVersion), unityVersion).Contains(src))
+                {
+                    return unityVersion;
+                }
+            }
+
+            return DEFAULT_UNITY_VERSION;
+        }
+    }
+}