Refactored out ParserContext abstraction.

Author: gsscoder

CommandLine.sln.DotSettings.user

@@ -2,6 +2,7 @@
 
   * Reverted same StyleCop default (see doc/Contribution).
   * tools/invariantstrtool.exe replaced by T4 template (project removed from GitHub).
+  * Removed superfluous abstraction.
 
 2013-02-23  Giacomo Stelluti Scala  <[email protected]>  
 

doc/ChangeLog

@@ -86,7 +86,6 @@
     <Compile Include="ParserConfigurator.cs">
       <DependentUpon>Parser.cs</DependentUpon>
     </Compile>
-    <Compile Include="ParserContext.cs" />
     <Compile Include="Helpers\Assumes.cs" />
     <Compile Include="Helpers\ReflectionCache.cs" />
     <Compile Include="Extensions\StringExtensions.cs" />

src/libcmdline/CommandLine.csproj

@@ -5,7 +5,7 @@
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
 // </auto-generated>
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 namespace CommandLine.Infrastructure
 {
     internal static class SR

src/libcmdline/Infrastructure/SR.strings.cs

@@ -27,6 +27,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Reflection;
+using System.Linq;
 using CommandLine.Extensions;
 using CommandLine.Helpers;
 using CommandLine.Infrastructure;
@@ -153,10 +154,9 @@ public bool ParseArguments(string[] args, object options, Action<string, object>
 
             object verbInstance = null;
 
-            var context = new ParserContext(args, options);
-            var result = DoParseArgumentsVerbs(context, ref verbInstance);
-
-            onVerbCommand(context.FirstArgument ?? string.Empty, result ? verbInstance : null);
+            var result = DoParseArgumentsVerbs(args, options, ref verbInstance);
+            
+            onVerbCommand(args.FirstOrDefault() ?? string.Empty, result ? verbInstance : null);
 
             return result;
         }
@@ -220,11 +220,9 @@ public bool ParseArgumentsStrict(string[] args, object options, Action<string, o
 
             object verbInstance = null;
 
-            var context = new ParserContext(args, options);
-
-            if (!DoParseArgumentsVerbs(context, ref verbInstance))
-            {
-                onVerbCommand(context.FirstArgument ?? string.Empty, null);
+            if (!DoParseArgumentsVerbs(args, options, ref verbInstance))
+            {
+                onVerbCommand(args.FirstOrDefault() ?? string.Empty, null);
 
                 InvokeAutoBuildIfNeeded(options);
 
@@ -238,9 +236,9 @@ public bool ParseArgumentsStrict(string[] args, object options, Action<string, o
                 }
 
                 return false;
-            }
-
-            onVerbCommand(context.FirstArgument ?? string.Empty, verbInstance);
+            }
+
+            onVerbCommand(args.FirstOrDefault() ?? string.Empty, verbInstance);
             return true;
         }
 
@@ -297,12 +295,10 @@ private bool DoParseArguments(string[] args, object options)
             var pair = ReflectionUtil.RetrieveMethod<HelpOptionAttribute>(options);
             var helpWriter = Settings.HelpWriter;
 
-            var context = new ParserContext(args, options);
-
             if (pair != null && helpWriter != null)
             {
                 // If help can be handled is displayed if is requested or if parsing fails
-                if (ParseHelp(args, pair.Right) || !DoParseArgumentsCore(context))
+                if (ParseHelp(args, pair.Right) || !DoParseArgumentsCore(args, options))
                 {
                     string helpText;
                     HelpOptionAttribute.InvokeMethod(options, pair, out helpText);
@@ -311,19 +307,19 @@ private bool DoParseArguments(string[] args, object options)
                 }
 
                 return true;
-            }
-
-            return DoParseArgumentsCore(context);
+            }
+
+            return DoParseArgumentsCore(args, options);
         }
 
-        private bool DoParseArgumentsCore(ParserContext context)
+        private bool DoParseArgumentsCore(string[] args, object options)
         {
             var hadError = false;
-            var optionMap = OptionMap.Create(context.Target, Settings);
+            var optionMap = OptionMap.Create(options, Settings);
             optionMap.SetDefaults();
-            var valueMapper = new ValueMapper(context.Target, Settings.ParsingCulture);
+            var valueMapper = new ValueMapper(options, Settings.ParsingCulture);
 
-            var arguments = new StringArrayEnumerator(context.Arguments);
+            var arguments = new StringArrayEnumerator(args);
             while (arguments.MoveNext())
             {
                 var argument = arguments.Current;
@@ -335,10 +331,10 @@ private bool DoParseArgumentsCore(ParserContext context)
                 var parser = ArgumentParser.Create(argument, Settings.IgnoreUnknownArguments);
                 if (parser != null)
                 {
-                    var result = parser.Parse(arguments, optionMap, context.Target);
+                    var result = parser.Parse(arguments, optionMap, options);
                     if ((result & PresentParserState.Failure) == PresentParserState.Failure)
                     {
-                        SetParserStateIfNeeded(context.Target, parser.PostParsingState);
+                        SetParserStateIfNeeded(options, parser.PostParsingState);
                         hadError = true;
                         continue;
                     }
@@ -362,54 +358,54 @@ private bool DoParseArgumentsCore(ParserContext context)
             return !hadError;
         }
 
-        private bool DoParseArgumentsVerbs(ParserContext context, ref object verbInstance)
+        private bool DoParseArgumentsVerbs(string[] args, object options, ref object verbInstance)
         {
-            var verbs = ReflectionUtil.RetrievePropertyList<VerbOptionAttribute>(context.Target);
-            var helpInfo = ReflectionUtil.RetrieveMethod<HelpVerbOptionAttribute>(context.Target);
-            if (context.HasNoArguments())
+            var verbs = ReflectionUtil.RetrievePropertyList<VerbOptionAttribute>(options);
+            var helpInfo = ReflectionUtil.RetrieveMethod<HelpVerbOptionAttribute>(options);
+            if (args.Length == 0)
             {
                 if (helpInfo != null || Settings.HelpWriter != null)
                 {
-                    DisplayHelpVerbText(context.Target, helpInfo, null);
+                    DisplayHelpVerbText(options, helpInfo, null);
                 }
 
                 return false;
             }
 
-            var optionMap = OptionMap.Create(context.Target, verbs, Settings);
+            var optionMap = OptionMap.Create(options, verbs, Settings);
 
             // Read the verb from command line arguments
-            if (TryParseHelpVerb(context.Arguments, context.Target, helpInfo, optionMap))
+            if (TryParseHelpVerb(args, options, helpInfo, optionMap))
             {
                 // Since user requested help, parsing is considered a fail
                 return false;
             }
 
-            var verbOption = optionMap[context.FirstArgument];
+            var verbOption = optionMap[args.First()];
 
             // User invoked a bad verb name
             if (verbOption == null)
             {
                 if (helpInfo != null)
                 {
-                    DisplayHelpVerbText(context.Target, helpInfo, null);
+                    DisplayHelpVerbText(options, helpInfo, null);
                 }
 
                 return false;
             }
 
-            verbInstance = verbOption.GetValue(context.Target);
+            verbInstance = verbOption.GetValue(options);
             if (verbInstance == null)
             {
                 // Developer has not provided a default value and did not assign an instance
-                verbInstance = verbOption.CreateInstance(context.Target);
-            }
-
-            var verbResult = DoParseArgumentsCore(context.ToCoreInstance(verbOption));
+                verbInstance = verbOption.CreateInstance(options);
+            }
+
+            var verbResult = DoParseArgumentsCore(args.Skip(1).ToArray(), verbInstance);
             if (!verbResult && helpInfo != null)
             {
                 // Particular verb parsing failed, we try to print its help
-                DisplayHelpVerbText(context.Target, helpInfo, context.FirstArgument);
+                DisplayHelpVerbText(options, helpInfo, args.First());
             }
 
             return verbResult;

src/libcmdline/Parser.cs

@@ -126,7 +126,7 @@ private void DoCoreTestForIndex(string[] args)
             ReflectionUtil.AssemblyFromWhichToPullInformation = Assembly.GetExecutingAssembly();
             var parser = new Parser(with => with.UseHelpWriter(testWriter));
             var result = parser.ParseArguments(args, options,
-                (verb, _) =>
+                (_, __) =>
                     {
                     });