use events instead of own listener

also re-format console-output
NobodysNightmare · Dec 27, 2013 · 8dc02fc · 8dc02fc
1 parent f935488
commit 8dc02fc
Show file tree

Hide file tree

Showing 10 changed files with 73 additions and 118 deletions.
diff --git a/CompareFS/CompareFS.csproj b/CompareFS/CompareFS.csproj
@@ -44,13 +44,9 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="DirectoryInfoExtensions.cs" />
-    <Compile Include="DirectoryModification.cs" />
-    <Compile Include="FileModification.cs" />
-    <Compile Include="ModificationType.cs" />
+    <Compile Include="ModificationEventArgs.cs" />
     <Compile Include="Pair.cs" />
     <Compile Include="PathComparator.cs" />
-    <Compile Include="PathModification.cs" />
-    <Compile Include="IPathModificationListener.cs" />
     <Compile Include="PathModificationConsoleWriter.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

diff --git a/CompareFS/DirectoryModification.cs b/CompareFS/DirectoryModification.cs
diff --git a/CompareFS/FileModification.cs b/CompareFS/FileModification.cs
diff --git a/CompareFS/IPathModificationListener.cs b/CompareFS/IPathModificationListener.cs
diff --git a/CompareFS/ModificationEventArgs.cs b/CompareFS/ModificationEventArgs.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace CompareFS
+{
+    public enum ModificationType
+    {
+        None,
+        Added,
+        Removed,
+        Changed
+    }
+
+    public class ModificationEventArgs : EventArgs
+    {
+        public string Path { get; private set; }
+
+        public ModificationType Type { get; private set; }
+
+        public ModificationEventArgs(string path, ModificationType type)
+        {
+            Path = path;
+            Type = type;
+        }
+    }
+}
diff --git a/CompareFS/ModificationType.cs b/CompareFS/ModificationType.cs
diff --git a/CompareFS/PathComparator.cs b/CompareFS/PathComparator.cs
@@ -10,19 +10,28 @@ namespace CompareFS
 {
     public class PathComparator
     {
-        private IPathModificationListener Listener;
+        public delegate void ModificationEventHandler(object sender, ModificationEventArgs args);
+
+        public event ModificationEventHandler Modification;
 
         public List<string> ExcludedFileExtensions { get; private set; }
 
         public bool CheckForModifications { get; set; }
 
-        public PathComparator(IPathModificationListener listener)
+        public PathComparator()
         {
-            Listener = listener;
-
             ExcludedFileExtensions = new List<string>();
         }
 
+        protected void OnModification(ModificationEventArgs args)
+        {
+            var handler = Modification;
+            if (handler != null)
+            {
+                handler(this, args);
+            }
+        }
+
         public void Compare(DirectoryInfo referenceDirectory, DirectoryInfo targetDirectory)
         {
             CompareSubdirectories(referenceDirectory, targetDirectory);
@@ -38,23 +47,23 @@ private void CompareSubdirectories(DirectoryInfo referenceDirectory, DirectoryIn
         {
             foreach (DirectoryInfo di in targetDirectory.EnumerateDirectories().Where(d => !referenceDirectory.HasSubdirectory(d)))
             {
-                Listener.OnModification(new DirectoryModification(di, ModificationType.Added));
+                OnModification(new ModificationEventArgs(di.FullName, ModificationType.Added));
             }
             foreach (DirectoryInfo di in referenceDirectory.EnumerateDirectories().Where(d => !targetDirectory.HasSubdirectory(d)))
             {
-                Listener.OnModification(new DirectoryModification(di, ModificationType.Removed));
+                OnModification(new ModificationEventArgs(di.FullName, ModificationType.Removed));
             }
         }
 
         private void CompareFiles(DirectoryInfo referenceDirectory, DirectoryInfo targetDirectory)
         {
             foreach (FileInfo fi in EnumerateLeftFilesMissingRight(targetDirectory, referenceDirectory))
             {
-                Listener.OnModification(new FileModification(fi, ModificationType.Added));
+                OnModification(new ModificationEventArgs(fi.FullName, ModificationType.Added));
             }
             foreach (FileInfo fi in EnumerateLeftFilesMissingRight(referenceDirectory, targetDirectory))
             {
-                Listener.OnModification(new FileModification(fi, ModificationType.Removed));
+                OnModification(new ModificationEventArgs(fi.FullName, ModificationType.Removed));
             }
 
             if (CheckForModifications)
@@ -63,7 +72,7 @@ private void CompareFiles(DirectoryInfo referenceDirectory, DirectoryInfo target
                 {
                     if (!CompareFilesAsync(pair.Left, pair.Right).Result)
                     {
-                        Listener.OnModification(new FileModification(pair.Left, ModificationType.Changed));
+                        OnModification(new ModificationEventArgs(pair.Left.FullName, ModificationType.Changed));
                     }
                 }
             }

diff --git a/CompareFS/PathModification.cs b/CompareFS/PathModification.cs
diff --git a/CompareFS/PathModificationConsoleWriter.cs b/CompareFS/PathModificationConsoleWriter.cs
@@ -5,30 +5,45 @@
 
 namespace CompareFS
 {
-    public class PathModificationConsoleWriter : IPathModificationListener
+    public class PathModificationConsoleWriter
     {
-        public void OnModification(PathModification modification)
+        public PathModificationConsoleWriter(PathComparator comparator)
         {
-            if (modification == null)
+            comparator.Modification += HandleModification;
+        }
+
+        private void HandleModification(object sender, ModificationEventArgs args)
+        {
+            if (args == null)
             {
-                throw new ArgumentNullException("modification");
+                throw new ArgumentNullException("args");
             }
 
-            switch (modification.Modification)
+            switch (args.Type)
             {
                 case ModificationType.Added:
-                    Console.Write("ADDED: ");
+                    WriteColored(ConsoleColor.Green, "ADDED:   ");
                     break;
                 case ModificationType.Removed:
-                    Console.Write("REMOVED: ");
+                    WriteColored(ConsoleColor.Red,   "REMOVED: ");
                     break;
                 case ModificationType.Changed:
-                    Console.Write("CHANGED: ");
+                    WriteColored(ConsoleColor.Yellow, "CHANGED: ");
                     break;
                 default:
                     break;
             }
-            Console.WriteLine(modification.Path);
+            Console.WriteLine(args.Path);
+        }
+
+        private static void WriteColored(ConsoleColor color, string value, params object[] args)
+        {
+            var oldColor = Console.ForegroundColor;
+            Console.ForegroundColor = color;
+
+            Console.Write(value, args);
+
+            Console.ForegroundColor = oldColor;
         }
     }
 }
diff --git a/ComparePathCLI/Program.cs b/ComparePathCLI/Program.cs
@@ -17,7 +17,8 @@ static void Main(string[] args)
                 return;
             }
 
-            var comparator = new PathComparator(new PathModificationConsoleWriter());
+            var comparator = new PathComparator();
+            var writer = new PathModificationConsoleWriter(comparator);
 
             for (int i = 0; i < args.Length - 2; i += 2)
             {