Changeset 2044


Ignore:
Timestamp:
5/4/2010 2:07:02 AM (3 years ago)
Author:
lowjoel
Message:

Implement the ICliConfigurer interface to allow configuration of objects from the command line, which helps to solve the compile problems with the change of erasure targets to plugins.

Location:
trunk/eraser
Files:
1 added
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/eraser/Eraser.DefaultPlugins/Eraser.DefaultPlugins.csproj

    r2043 r2044  
    9999    </Compile> 
    100100    <Compile Include="ErasureTargets\RecycleBinErasureTarget.cs" /> 
     101    <Compile Include="ErasureTargets\RecycleBinErasureTargetConfigurer.cs" /> 
    101102    <Compile Include="ErasureTargets\UnusedSpaceErasureTarget.cs" /> 
    102103    <Compile Include="ErasureTargets\UnusedSpaceErasureTargetConfigurer.cs"> 

  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FileErasureTarget.cs

    r2040 r2044  
    6161        public override IErasureTargetConfigurer Configurer 
    6262        { 
    63             get { return new FileErasureTargetSettings(); } 
     63            get { return new FileErasureTargetConfigurer(); } 
    6464        } 
    6565 

  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FileErasureTargetConfigurer.cs

    r2043 r2044  
    2929using System.Windows.Forms; 
    3030 
     31using System.Text.RegularExpressions; 
     32 
    3133using Eraser.Manager; 
    3234using Eraser.Util; 
    … …  
    4143        } 
    4244 
    43         #region IErasureTargetConfigurer Members 
     45        #region IConfigurer<ErasureTarget> Members 
    4446 
    4547        public void LoadFrom(ErasureTarget target) 
    … …  
    7274        #endregion 
    7375 
     76        #region ICliConfigurer<ErasureTarget> Members 
     77 
     78        public void Help() 
     79        { 
     80            throw new NotImplementedException(); 
     81        } 
     82 
     83        public bool ProcessArgument(string argument) 
     84        { 
     85            Regex regex = new Regex("file=(?<fileName>.*)", 
     86                RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.RightToLeft); 
     87            Match match = regex.Match(argument); 
     88 
     89            if (match.Groups["fileName"].Success) 
     90            { 
     91                filePath.Text = match.Groups["fileName"].Value; 
     92                return true; 
     93            } 
     94 
     95            return false; 
     96        } 
     97 
     98        #endregion 
     99 
    74100        private void fileBrowse_Click(object sender, EventArgs e) 
    75101        { 

  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FolderErasureTarget.cs

    r2039 r2044  
    7979        public override IErasureTargetConfigurer Configurer 
    8080        { 
    81             get { return new FolderErasureTargetSettings(); } 
     81            get { return new FolderErasureTargetConfigurer(); } 
    8282        } 
    8383 

  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/FolderErasureTargetConfigurer.cs

    r2043 r2044  
    2929using System.Windows.Forms; 
    3030 
     31using System.Text.RegularExpressions; 
     32 
    3133using Eraser.Manager; 
    3234using Eraser.Util; 
    … …  
    4143        } 
    4244 
    43         #region IErasureTargetConfigurer Members 
     45        #region IConfigurer<ErasureTarget> Members 
    4446 
    4547        public void LoadFrom(ErasureTarget target) 
    … …  
    7880        #endregion 
    7981 
     82        #region ICliConfigurer<ErasureTarget> Members 
     83 
     84        public void Help() 
     85        { 
     86            throw new NotImplementedException(); 
     87        } 
     88 
     89        public bool ProcessArgument(string argument) 
     90        { 
     91            //The directory target, taking a list of + and - wildcard expressions. 
     92            Regex regex = new Regex("dir=(?<directoryName>.*)(?<directoryParams>(?<directoryExcludeMask>,-[^,]+)|(?<directoryIncludeMask>,\\+[^,]+)|(?<directoryDeleteIfEmpty>,deleteIfEmpty(=(?<directoryDeleteIfEmptyValue>true|false))?))*", 
     93                RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.RightToLeft); 
     94            Match match = regex.Match(argument); 
     95 
     96            if (match.Groups["directoryName"].Success) 
     97            { 
     98                folderPath.Text = match.Groups["directoryName"].Value; 
     99                if (!match.Groups["directoryDeleteIfEmpty"].Success) 
     100                    folderDelete.Checked = false; 
     101                else if (!match.Groups["directoryDeleteIfEmptyValue"].Success) 
     102                    folderDelete.Checked = true; 
     103                else 
     104                    folderDelete.Checked = 
     105                        trueValues.IndexOf(match.Groups["directoryDeleteIfEmptyValue"].Value) != -1; 
     106 
     107                if (match.Groups["directoryExcludeMask"].Success) 
     108                    folderExclude.Text += match.Groups["directoryExcludeMask"].Value.Remove(0, 2) + ' '; 
     109                if (match.Groups["directoryIncludeMask"].Success) 
     110                    folderInclude.Text += match.Groups["directoryIncludeMask"].Value.Remove(0, 2) + ' '; 
     111            } 
     112 
     113            return false; 
     114        } 
     115 
     116        #endregion 
     117 
    80118        private void folderBrowse_Click(object sender, EventArgs e) 
    81119        { 

  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/UnusedSpaceErasureTarget.cs

    r2039 r2044  
    113113        public override IErasureTargetConfigurer Configurer 
    114114        { 
    115             get { return new UnusedSpaceErasureTargetSettings(); } 
     115            get { return new UnusedSpaceErasureTargetConfigurer(); } 
    116116        } 
    117117 

  • trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/UnusedSpaceErasureTargetConfigurer.cs

    r2043 r2044  
    2828using System.Text; 
    2929using System.Windows.Forms; 
     30 
    3031using System.IO; 
     32using System.Text.RegularExpressions; 
    3133 
    3234using Eraser.Manager; 
    … …  
    9597        } 
    9698 
    97         #region IErasureTargetConfigurer Members 
     99        #region IConfigurer<ErasureTarget> Members 
    98100 
    99101        public void LoadFrom(ErasureTarget target) 
    … …  
    120122            unused.EraseClusterTips = unusedClusterTips.Checked; 
    121123            return true; 
     124        } 
     125 
     126        #endregion 
     127 
     128        #region ICliConfigurer<ErasureTarget> Members 
     129 
     130        public void Help() 
     131        { 
     132            throw new NotImplementedException(); 
     133        } 
     134 
     135        public bool ProcessArgument(string argument) 
     136        { 
     137            //The unused space erasure target, taking the optional clusterTips 
     138            //argument which defaults to true; if none is specified it's assumed 
     139            //false 
     140            Regex regex = new Regex("unused=(?<unusedVolume>.*)(?<unusedTips>,clusterTips(=(?<unusedTipsValue>true|false))?)?", 
     141                RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.RightToLeft); 
     142            Match match = regex.Match(argument); 
     143 
     144            if (match.Groups["unusedVolume"].Success) 
     145            { 
     146                foreach (object item in unusedDisk.Items) 
     147                if (((DriveItem)item).Drive.ToUpperInvariant() == 
     148                    match.Groups["unusedVolume"].Value.ToUpperInvariant()) 
     149                { 
     150                    unusedDisk.SelectedItem = item; 
     151                } 
     152     
     153                if (!match.Groups["unusedTips"].Success) 
     154                    unusedClusterTips.Checked = false; 
     155                else if (!match.Groups["unusedTipsValue"].Success) 
     156                    unusedClusterTips.Checked = true; 
     157                else 
     158                    unusedClusterTips.Checked = 
     159                        trueValues.IndexOf(match.Groups["unusedTipsValue"].Value) != -1; 
     160            } 
     161 
     162            return false; 
    122163        } 
    123164 

  • trunk/eraser/Eraser.Manager/Eraser.Manager.csproj

    r2036 r2044  
    7171    <Compile Include="Executor.cs" /> 
    7272    <Compile Include="FileSystem.cs" /> 
     73    <Compile Include="IConfigurer.cs" /> 
    7374    <Compile Include="IRegistrar.cs" /> 
    7475    <Compile Include="ManagerLibrary.cs" /> 

  • trunk/eraser/Eraser.Manager/ErasureTarget.cs

    r2042 r2044  
    179179    /// object. 
    180180    /// </summary> 
    181     public interface IErasureTargetConfigurer : IConfigurer<ErasureTarget> 
     181    public interface IErasureTargetConfigurer : ICliConfigurer<ErasureTarget> 
    182182    { 
    183183    } 

  • trunk/eraser/Eraser.Manager/IConfigurer.cs

    r2042 r2044  
    4848        bool SaveTo(T target); 
    4949    } 
     50 
     51    /// <summary> 
     52    /// Represents an object which is able to configure a given instance of 
     53    /// <typeparamref name="T"/> from the Command Line. 
     54    /// </summary> 
     55    /// <typeparam name="T">The type to configure</typeparam> 
     56    public interface ICliConfigurer<T> : IConfigurer<T> 
     57    { 
     58        /// <summary> 
     59        /// Displays the help for the current configurer. 
     60        /// </summary> 
     61        void Help(); 
     62 
     63        /// <summary> 
     64        /// Sets the configuration of the current configurer from the provided 
     65        /// command line argument. 
     66        /// </summary> 
     67        /// <param name="argument">The argument on the command line.</param> 
     68        /// <returns>True if the argument is accepted by the configurer.</returns> 
     69        bool ProcessArgument(string argument); 
     70    } 
    5071} 

  • trunk/eraser/Eraser/Program.cs

    r2015 r2044  
    400400            //Parse the rest of the command line parameters as target expressions. 
    401401            List<string> trueValues = new List<string>(new string[] { "yes", "true" }); 
    402             string[] strings = new string[] { 
    403                 //The recycle bin target 
    404                 "(?<recycleBin>recyclebin)", 
    405  
    406                 //The unused space erasure target, taking the optional clusterTips 
    407                 //argument which defaults to true; if none is specified it's assumed 
    408                 //false 
    409                 "unused=(?<unusedVolume>.*)(?<unusedTips>,clusterTips(=(?<unusedTipsValue>true|false))?)?", 
    410  
    411                 //The directory target, taking a list of + and - wildcard expressions. 
    412                 "dir=(?<directoryName>.*)(?<directoryParams>(?<directoryExcludeMask>,-[^,]+)|(?<directoryIncludeMask>,\\+[^,]+)|(?<directoryDeleteIfEmpty>,deleteIfEmpty(=(?<directoryDeleteIfEmptyValue>true|false))?))*", 
    413  
    414                 //The file target. 
    415                 "file=(?<fileName>.*)" 
    416             }; 
    417  
    418             Regex regex = new Regex(string.Join("|", strings), 
    419                 RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.RightToLeft); 
    420402            foreach (string argument in arguments.PositionalArguments) 
    421403            { 
    422                 Match match = regex.Match(argument); 
    423                 if (match.Captures.Count == 0) 
     404                bool processed = false; 
     405                foreach (ErasureTarget target in ManagerLibrary.Instance.ErasureTargetRegistrar) 
     406                    if (target.Configurer.ProcessArgument(argument)) 
     407                    { 
     408                        target.Method = method; 
     409                        task.Targets.Add(target); 
     410                        processed = true; 
     411                        break; 
     412                    } 
     413 
     414                if (!processed) 
    424415                { 
    425416                    Console.WriteLine("Unknown argument: {0}, skipped.", argument); 
    426417                    continue; 
    427418                } 
    428  
    429                 ErasureTarget target = null; 
    430                 if (match.Groups["recycleBin"].Success) 
    431                 { 
    432                     target = new RecycleBinTarget(); 
    433                 } 
    434                 else if (match.Groups["unusedVolume"].Success) 
    435                 { 
    436                     UnusedSpaceTarget unusedSpaceTarget = new UnusedSpaceTarget(); 
    437                     target = unusedSpaceTarget; 
    438                     unusedSpaceTarget.Drive = match.Groups["unusedVolume"].Value; 
    439  
    440                     if (!match.Groups["unusedTips"].Success) 
    441                         unusedSpaceTarget.EraseClusterTips = false; 
    442                     else if (!match.Groups["unusedTipsValue"].Success) 
    443                         unusedSpaceTarget.EraseClusterTips = true; 
    444                     else 
    445                         unusedSpaceTarget.EraseClusterTips = 
    446                             trueValues.IndexOf(match.Groups["unusedTipsValue"].Value) != -1; 
    447                 } 
    448                 else if (match.Groups["directoryName"].Success) 
    449                 { 
    450                     FolderTarget folderTarget = new FolderTarget(); 
    451                     target = folderTarget; 
    452  
    453                     folderTarget.Path = match.Groups["directoryName"].Value; 
    454                     if (!match.Groups["directoryDeleteIfEmpty"].Success) 
    455                         folderTarget.DeleteIfEmpty = false; 
    456                     else if (!match.Groups["directoryDeleteIfEmptyValue"].Success) 
    457                         folderTarget.DeleteIfEmpty = true; 
    458                     else 
    459                         folderTarget.DeleteIfEmpty = 
    460                             trueValues.IndexOf(match.Groups["directoryDeleteIfEmptyValue"].Value) != -1; 
    461                     if (match.Groups["directoryExcludeMask"].Success) 
    462                         folderTarget.ExcludeMask += match.Groups["directoryExcludeMask"].Value.Remove(0, 2) + ' '; 
    463                     if (match.Groups["directoryIncludeMask"].Success) 
    464                         folderTarget.IncludeMask += match.Groups["directoryIncludeMask"].Value.Remove(0, 2) + ' '; 
    465                 } 
    466                 else if (match.Groups["fileName"].Success) 
    467                 { 
    468                     FileTarget fileTarget = new FileTarget(); 
    469                     target = fileTarget; 
    470                     fileTarget.Path = match.Groups["fileName"].Value; 
    471                 } 
    472  
    473                 if (target == null) 
    474                     continue; 
    475  
    476                 target.Method = method; 
    477                 task.Targets.Add(target); 
    478419            } 
    479420 

  • trunk/eraser/Eraser/TaskDataSelectionForm.cs

    r2029 r2044  
    6767 
    6868            //Insert the types of erasure targets 
    69             typeCmb.Items.Add(new ErasureType("File", new FileTarget())); 
    70             typeCmb.Items.Add(new ErasureType("Files in Folder", new FolderTarget())); 
    71             typeCmb.Items.Add(new ErasureType("Unused disk space", new UnusedSpaceTarget())); 
    72             typeCmb.Items.Add(new ErasureType("Recycle Bin", new RecycleBinTarget())); 
    73             typeCmb.SelectedIndex = 0; 
     69            foreach (ErasureTarget target in ManagerLibrary.Instance.ErasureTargetRegistrar) 
     70                typeCmb.Items.Add(new ErasureType(target.GetType().Name, target)); 
     71            if (typeCmb.Items.Count != 0)  
     72                typeCmb.SelectedIndex = 0; 
    7473 
    75              
    7674            //And the methods list 
    77             this.methodCmb.Items.Add(ErasureMethodRegistrar.Default); 
     75            methodCmb.Items.Add(ErasureMethodRegistrar.Default); 
    7876            foreach (ErasureMethod method in ManagerLibrary.Instance.ErasureMethodRegistrar) 
    79                 this.methodCmb.Items.Add(method); 
    80             if (this.methodCmb.Items.Count != 0) 
    81                 this.methodCmb.SelectedIndex = 0; 
     77                methodCmb.Items.Add(method); 
     78            if (methodCmb.Items.Count != 0) 
     79                methodCmb.SelectedIndex = 0; 
    8280        } 
    8381 
Note: See TracChangeset for help on using the changeset viewer.