Remove constraint on T for ParseArguments with factory

src/CommandLine/Core/InstanceBuilder.cs

@@ -39,7 +39,7 @@ public static ParserResult<T> Build<T>(
 
  Func<T> makeDefault = () =>
  typeof(T).IsMutable()
- ? factory.MapValueOrDefault(f => f(), Activator.CreateInstance<T>())
+ ? factory.MapValueOrDefault(f => f(), () => Activator.CreateInstance<T>())
  : ReflectionHelper.CreateDefaultImmutableInstance<T>(
  (from p in specProps select p.Specification.ConversionType).ToArray());
 
@@ -128,7 +128,7 @@ public static ParserResult<T> Build<T>(
 
  private static T BuildMutable<T>(Maybe<Func<T>> factory, IEnumerable<SpecificationProperty> specPropsWithValue, List<Error> setPropertyErrors )
  {
- var mutable = factory.MapValueOrDefault(f => f(), Activator.CreateInstance<T>());
+ var mutable = factory.MapValueOrDefault(f => f(), () => Activator.CreateInstance<T>());
 
  setPropertyErrors.AddRange(
  mutable.SetProperties(

src/CommandLine/Core/ReflectionExtensions.cs

@@ -133,10 +133,21 @@ public static bool IsMutable(this Type type)
  if(type == typeof(object))
  return true;
 
- var props = type.GetTypeInfo().GetProperties(BindingFlags.Public | BindingFlags.Instance).Any(p => p.CanWrite);
- var fields = type.GetTypeInfo().GetFields(BindingFlags.Public | BindingFlags.Instance).Any();
+ // Find all inherited defined properties and fields on the type
+ var inheritedTypes = type.GetTypeInfo().FlattenHierarchy().Select(i => i.GetTypeInfo());
 
- return props || fields;
+ foreach (var inheritedType in inheritedTypes) 
+ {
+ if (
+ inheritedType.GetTypeInfo().GetProperties(BindingFlags.Public | BindingFlags.Instance).Any(p => p.CanWrite) ||
+ inheritedType.GetTypeInfo().GetFields(BindingFlags.Public | BindingFlags.Instance).Any()
+ )
+ {
+ return true;
+ }
+ }
+
+ return false;
  }
 
  public static object CreateDefaultForImmutable(this Type type)

src/CommandLine/Infrastructure/CSharpx/Maybe.cs

@@ -371,6 +371,14 @@ public static T2 MapValueOrDefault<T1, T2>(this Maybe<T1> maybe, Func<T1, T2> fu
  return maybe.MatchJust(out value1) ? func(value1) : noneValue;
  }
 
+ /// <summary>
+ /// If contains a values executes a mapping function over it, otherwise returns the value from <paramref name="noneValueFactory"/>.
+ /// </summary>
+ public static T2 MapValueOrDefault<T1, T2>(this Maybe<T1> maybe, Func<T1, T2> func, Func<T2> noneValueFactory) {
+ T1 value1;
+ return maybe.MatchJust(out value1) ? func(value1) : noneValueFactory();
+ }
+
  /// <summary>
  /// Returns an empty list when given <see cref="CSharpx.Nothing{T}"/> or a singleton list when given a <see cref="CSharpx.Just{T}"/>.
  /// </summary>

src/CommandLine/Parser.cs

@@ -116,7 +116,6 @@ public ParserResult<T> ParseArguments<T>(IEnumerable<string> args)
  /// and a sequence of <see cref="CommandLine.Error"/>.</returns>
  /// <exception cref="System.ArgumentNullException">Thrown if one or more arguments are null.</exception>
  public ParserResult<T> ParseArguments<T>(Func<T> factory, IEnumerable<string> args)
- where T : new()
  {
  if (factory == null) throw new ArgumentNullException("factory");
  if (!typeof(T).IsMutable()) throw new ArgumentException("factory");

tests/CommandLine.Tests/Fakes/Mutable_Without_Empty_Constructor.cs

@@ -0,0 +1,19 @@
+// Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
+
+namespace CommandLine.Tests.Fakes 
+{
+ class Mutable_Without_Empty_Constructor 
+ {
+ [Option("amend", HelpText = "Used to amend the tip of the current branch.")]
+ public bool Amend { get; set; }
+
+ private Mutable_Without_Empty_Constructor() 
+ {
+ }
+
+ public static Mutable_Without_Empty_Constructor Create() 
+ {
+ return new Mutable_Without_Empty_Constructor();
+ }
+ }
+}

tests/CommandLine.Tests/Fakes/Options_With_Only_Explicit_Interface.cs

@@ -0,0 +1,9 @@
+namespace CommandLine.Tests.Fakes
+{
+ class Options_With_Only_Explicit_Interface : IInterface_With_Two_Scalar_Options
+ {
+ bool IInterface_With_Two_Scalar_Options.Verbose { get; set; }
+
+ string IInterface_With_Two_Scalar_Options.InputFile { get; set; }
+ }
+}

tests/CommandLine.Tests/Unit/Core/InstanceBuilderTests.cs

@@ -787,6 +787,20 @@ public void Specifying_options_two_or_more_times_with_mixed_short_long_options_g
  ((NotParsed<Simple_Options>)result).Errors.Should().HaveCount(x => x == expected);
  }
 
+ [Theory]
+ [InlineData(new[] { "--inputfile=file1.bin" }, "file1.bin")]
+ [InlineData(new[] { "--inputfile", "file2.txt" }, "file2.txt")]
+ public void Can_define_options_on_explicit_interface_properties(string[] arguments, string expected) 
+ {
+ // Exercize system
+ var result = InvokeBuild<Options_With_Only_Explicit_Interface>(
+ arguments);
+
+ // Verify outcome
+ expected.Should().BeEquivalentTo(((IInterface_With_Two_Scalar_Options)((Parsed<Options_With_Only_Explicit_Interface>)result).Value).InputFile);
+ }
+
+
  [Theory]
  [InlineData(new[] { "--inputfile=file1.bin" }, "file1.bin")]
  [InlineData(new[] { "--inputfile", "file2.txt" }, "file2.txt")]

tests/CommandLine.Tests/Unit/Issue591ests.cs

@@ -0,0 +1,29 @@
+using System.Linq;
+using CommandLine.Tests.Fakes;
+using CommandLine.Text;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+//Issue #591
+//When options class is only having explicit interface declarations, it should be detected as mutable.
+
+namespace CommandLine.Tests.Unit
+{
+ public class Issue591ests
+ {
+ [Fact]
+ public void Parse_option_with_only_explicit_interface_implementation()
+ {
+ string actual = string.Empty;
+
+ var arguments = new[] { "--inputfile", "file2.txt" };
+ var result = Parser.Default.ParseArguments<Options_With_Only_Explicit_Interface>(arguments);
+ result.WithParsed(options => {
+ actual = ((IInterface_With_Two_Scalar_Options)options).InputFile;
+ });
+
+ actual.Should().Be("file2.txt");
+ }
+ }
+}

tests/CommandLine.Tests/Unit/Issue70Tests.cs

@@ -0,0 +1,29 @@
+using System.Linq;
+using CommandLine.Tests.Fakes;
+using CommandLine.Text;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+//Issue #70
+//When the factory overload is used for ParseArguments, there should be no constraint not having an empty constructor.
+
+namespace CommandLine.Tests.Unit
+{
+ public class Issue70Tests
+ {
+ [Fact]
+ public void Create_instance_with_factory_method_should_not_fail()
+ {
+ bool actual = false;
+
+ var arguments = new[] { "--amend" };
+ var result = Parser.Default.ParseArguments(() => Mutable_Without_Empty_Constructor.Create(), arguments);
+ result.WithParsed(options => {
+ actual = options.Amend;
+ });
+
+ actual.Should().BeTrue();
+ }
+ }
+}