Refactor IMerge to be IEnumerable

GqlPlus.sln

@@ -20,22 +20,12 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		.editorconfig = .editorconfig
 		.gitignore = .gitignore
 		.prettierrc.yml = .prettierrc.yml
-		collect-all.ps1 = collect-all.ps1
 		coverage.ps1 = coverage.ps1
 		coverage.runsettings = coverage.runsettings
 		Directory.Build.props = Directory.Build.props
 		.github\workflows\dotnet-test.yml = .github\workflows\dotnet-test.yml
 	EndProjectSection
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "graphql-plus", "graphql-plus", "{74C0DC37-FD8F-419A-A5CE-A0F27946F3B0}"
-	ProjectSection(SolutionItems) = preProject
-		graphql-plus\Definition.md = graphql-plus\Definition.md
-		graphql-plus\Introspection.md = graphql-plus\Introspection.md
-		graphql-plus\Operation.md = graphql-plus\Operation.md
-		graphql-plus\Schema.md = graphql-plus\Schema.md
-		graphql-plus\toc.yml = graphql-plus\toc.yml
-	EndProjectSection
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GqlPlus.Verifier.ComponentTests", "test\GqlPlus.Verifier.ComponentTests\GqlPlus.Verifier.ComponentTests.csproj", "{D97ABCF2-E6C4-4384-AFB7-C55943EBE1E2}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GqlPlus.Verifier.TestBase", "test\GqlPlus.Verifier.TestBase\GqlPlus.Verifier.TestBase.csproj", "{B73CDEC7-3F67-444E-8A06-16C20DF56DFB}"

src/GqlPlus.Verifier/Merging/BaseMerger.cs

@@ -3,9 +3,9 @@
 public class BaseMerger<TItem>
   : IMerge<TItem>
 {
-  public virtual bool CanMerge(TItem[] items)
-    => items.Length > 0;
+  public virtual bool CanMerge(IEnumerable<TItem> items)
+    => items.Any();
 
-  public virtual TItem[] Merge(TItem[] items)
-    => items ?? [];
+  public virtual IEnumerable<TItem> Merge(IEnumerable<TItem> items)
+    => items ?? Enumerable.Empty<TItem>();
 }

src/GqlPlus.Verifier/Merging/GroupsMerger.cs

@@ -9,9 +9,9 @@ public abstract class GroupsMerger<TItem>
 
   protected abstract bool CanMergeGroup(IGrouping<string, TItem> group);
 
-  public override bool CanMerge(TItem[] items)
+  public override bool CanMerge(IEnumerable<TItem> items)
     => base.CanMerge(items) && items.GroupBy(ItemGroupKey).All(CanMergeGroup);
 
-  public override TItem[] Merge(TItem[] items)
+  public override IEnumerable<TItem> Merge(IEnumerable<TItem> items)
     => items?.GroupMerger(ItemGroupKey, MergeGroup) ?? [];
 }

src/GqlPlus.Verifier/Merging/IMerge.cs

@@ -2,6 +2,6 @@
 
 public interface IMerge<TItem>
 {
-  bool CanMerge(TItem[] items);
-  TItem[] Merge(TItem[] items);
+  bool CanMerge(IEnumerable<TItem> items);
+  IEnumerable<TItem> Merge(IEnumerable<TItem> items);
 }

src/GqlPlus.Verifier/Merging/MergeAllTypes.cs

@@ -1,5 +1,4 @@
-using GqlPlus.Verifier.Ast;
-using GqlPlus.Verifier.Ast.Schema;
+using GqlPlus.Verifier.Ast.Schema;
 
 namespace GqlPlus.Verifier.Merging;
 
@@ -10,19 +9,19 @@ internal class MergeAllTypes(
   IMerge<ScalarDeclAst> scalars
 ) : IMerge<AstType>
 {
-  public bool CanMerge(AstType[] items)
+  public bool CanMerge(IEnumerable<AstType> items)
   {
     FixupEnums(items.OfType<EnumDeclAst>(), items.OfType<OutputDeclAst>());
 
     return items.Select(i => i.GetType()).Distinct().Count() == 1;
   }
 
-  public AstType[] Merge(AstType[] items)
+  public IEnumerable<AstType> Merge(IEnumerable<AstType> items)
   {
-    var enumTypes = items.ArrayOf<EnumDeclAst>();
-    var inputTypes = items.ArrayOf<InputDeclAst>();
-    var outputTypes = items.ArrayOf<OutputDeclAst>();
-    var scalarTypes = items.ArrayOf<ScalarDeclAst>();
+    var enumTypes = items.OfType<EnumDeclAst>();
+    var inputTypes = items.OfType<InputDeclAst>();
+    var outputTypes = items.OfType<OutputDeclAst>();
+    var scalarTypes = items.OfType<ScalarDeclAst>();
 
     FixupEnums(enumTypes, outputTypes);
 

src/GqlPlus.Verifier/Merging/MergeCategories.cs

@@ -5,7 +5,7 @@ namespace GqlPlus.Verifier.Merging;
 internal class MergeCategories
   : AliasedMerger<CategoryDeclAst>
 {
-  public override bool CanMerge(CategoryDeclAst[] items)
+  public override bool CanMerge(IEnumerable<CategoryDeclAst> items)
     => base.CanMerge(items)
       && items.CanMerge(item => item.Option);
 

src/GqlPlus.Verifier/Merging/MergeDirectives.cs

@@ -9,13 +9,13 @@ IMerge<ParameterAst> parameters
   protected override string ItemMatchKey(DirectiveDeclAst item)
     => item.Option.ToString();
 
-  public override bool CanMerge(DirectiveDeclAst[] items)
+  public override bool CanMerge(IEnumerable<DirectiveDeclAst> items)
     => base.CanMerge(items)
       && items.ManyCanMerge(d => d.Parameters, parameters);
 
   protected override DirectiveDeclAst MergeGroup(IEnumerable<DirectiveDeclAst> group)
     => base.MergeGroup(group) with {
-      Parameters = group.ManyMerge(item => item.Parameters, parameters),
+      Parameters = [.. group.ManyMerge(item => item.Parameters, parameters)],
       Locations = group.Aggregate(DirectiveLocation.None, (l, d) => d.Locations | l),
     };
 }

src/GqlPlus.Verifier/Merging/MergeEnums.cs

@@ -9,12 +9,12 @@ IMerge<EnumValueAst> enumValues
   protected override string ItemMatchKey(EnumDeclAst item)
     => item.Extends ?? "";
 
-  public override bool CanMerge(EnumDeclAst[] items)
+  public override bool CanMerge(IEnumerable<EnumDeclAst> items)
     => base.CanMerge(items)
       && items.ManyCanMerge(e => e.Values, enumValues);
 
   protected override EnumDeclAst MergeGroup(IEnumerable<EnumDeclAst> group)
     => base.MergeGroup(group) with {
-      Values = group.ManyMerge(item => item.Values, enumValues),
+      Values = [.. group.ManyMerge(item => item.Values, enumValues)],
     };
 }

src/GqlPlus.Verifier/Merging/MergeExtensions.cs

@@ -79,7 +79,7 @@ public static string[] MergeAliases<TItem>(this IEnumerable<TItem> items)
     where TItem : AstAliased
     => [.. items.SelectMany(item => item.Aliases).Distinct()];
 
-  public static TItem[] GroupMerger<TItem>(this IEnumerable<TItem> items, Func<TItem, string> key, Func<TItem[], TItem> merger)
+  public static IEnumerable<TItem> GroupMerger<TItem>(this IEnumerable<TItem> items, Func<TItem, string> key, Func<TItem[], TItem> merger)
   {
     List<Indexed<TItem>> result = [];
     var groups = items.Select(Indexed<TItem>.To).GroupBy(i => key(i.Item));
@@ -89,14 +89,11 @@ public static TItem[] GroupMerger<TItem>(this IEnumerable<TItem> items, Func<TIt
       result.Add(new(item, group.Min(i => i.Index)));
     }
 
-    return [.. result.OrderBy(i => i.Index).Select(i => i.Item)];
+    return result.OrderBy(i => i.Index).Select(i => i.Item);
   }
 
-  public static TGroup[] ManyMerge<TItem, TGroup>(this IEnumerable<TItem> items, Func<TItem, IEnumerable<TGroup>> many, IMerge<TGroup> merger)
-  {
-    TGroup[] items1 = [.. items.SelectMany(many)];
-    return merger.Merge(items1);
-  }
+  public static IEnumerable<TGroup> ManyMerge<TItem, TGroup>(this IEnumerable<TItem> items, Func<TItem, IEnumerable<TGroup>> many, IMerge<TGroup> merger)
+    => merger.Merge(items.SelectMany(many));
 
   private record struct Indexed<TItem>(TItem Item, int Index)
   {

src/GqlPlus.Verifier/Merging/MergeInputFields.cs

@@ -5,7 +5,7 @@ namespace GqlPlus.Verifier.Merging;
 internal class MergeInputFields
   : FieldsMerger<InputFieldAst, InputReferenceAst>
 {
-  public override bool CanMerge(InputFieldAst[] items)
+  public override bool CanMerge(IEnumerable<InputFieldAst> items)
     => base.CanMerge(items)
        && items.CanMerge(item => item.Default);
 }

src/GqlPlus.Verifier/Merging/MergeOutputFields.cs

@@ -12,6 +12,6 @@ protected override bool CanMergeGroup(IGrouping<string, OutputFieldAst> group)
 
   protected override OutputFieldAst MergeGroup(IEnumerable<OutputFieldAst> group)
     => base.MergeGroup(group) with {
-      Parameters = group.ManyMerge(item => item.Parameters, parameters),
+      Parameters = [.. group.ManyMerge(item => item.Parameters, parameters)],
     };
 }

src/GqlPlus.Verifier/Merging/MergeScalars.cs

@@ -10,7 +10,7 @@ IMerge<ScalarRegexAst> regexes
   protected override string ItemMatchKey(ScalarDeclAst item)
     => item.Kind.ToString();
 
-  public override bool CanMerge(ScalarDeclAst[] items)
+  public override bool CanMerge(IEnumerable<ScalarDeclAst> items)
     => base.CanMerge(items)
       && items.ManyCanMerge(i => i.Ranges, ranges)
       && items.ManyGroupCanMerge(i => i.Regexes, r => r.Regex, regexes);

src/GqlPlus.Verifier/Merging/MergeSchemas.cs

@@ -17,17 +17,17 @@ protected override bool CanMergeGroup(IGrouping<string, SchemaAst> group)
     var directives = Just<DirectiveDeclAst>(group);
     var astTypes = Just<AstType>(group);
 
-    var categoriesCanMerge = categories.Length == 0 || categoryMerger.CanMerge(categories);
-    var directivesCanMerge = directives.Length == 0 || directiveMerger.CanMerge(directives);
-    var astTypesCanMerge = astTypes.Length == 0 || astTypeMerger.CanMerge(astTypes);
+    var categoriesCanMerge = categories.Any() || categoryMerger.CanMerge(categories);
+    var directivesCanMerge = directives.Any() || directiveMerger.CanMerge(directives);
+    var astTypesCanMerge = astTypes.Any() || astTypeMerger.CanMerge(astTypes);
 
     return categoriesCanMerge
      && directivesCanMerge
      && (astTypesCanMerge || true);
   }
 
-  private static TItem[] Just<TItem>(IEnumerable<SchemaAst> group)
-    => group.SelectMany(item => item.Declarations.OfType<TItem>()).ToArray();
+  private static IEnumerable<TItem> Just<TItem>(IEnumerable<SchemaAst> group)
+    => group.SelectMany(item => item.Declarations.OfType<TItem>());
 
   protected override SchemaAst MergeGroup(IEnumerable<SchemaAst> group)
   {

src/GqlPlus.Verifier/Merging/ObjectsMerger.cs

@@ -15,7 +15,7 @@ IMerge<TField> fields
   protected override string ItemMatchKey(TObject item)
     => item.Extends?.Name ?? "";
 
-  public override bool CanMerge(TObject[] items)
+  public override bool CanMerge(IEnumerable<TObject> items)
   {
     var baseCanMerge = base.CanMerge(items);
     var typeParametersCanMerge = items.ManyCanMerge(item => item.TypeParameters, typeParameters);
@@ -32,9 +32,9 @@ protected override TObject MergeGroup(IEnumerable<TObject> group)
     var alternateAsts = group.ManyMerge(item => item.Alternates, alternates);
 
     return base.MergeGroup(group) with {
-      TypeParameters = typeParameterAsts,
-      Fields = fieldAsts,
-      Alternates = alternateAsts,
+      TypeParameters = [.. typeParameterAsts],
+      Fields = [.. fieldAsts],
+      Alternates = [.. alternateAsts],
     };
   }
 }

test/GqlPlus.Verifier.ClassTests/Merging/MergeTypeParametersTests.cs

@@ -15,7 +15,7 @@ public void Merge_ManyItems_ReturnsItem(string name)
 
     using var scope = new AssertionScope();
 
-    result.Should().BeOfType<TypeParameterAst[]>();
+    result.Should().BeAssignableTo<IEnumerable<TypeParameterAst>>();
   }
 
   private readonly MergeTypeParameters _merger = new();

test/GqlPlus.Verifier.ClassTests/Merging/TestBase.cs

@@ -75,7 +75,7 @@ protected void Merge_Expected(TItem[] items, params TItem[] expected)
 
     using var scope = new AssertionScope();
 
-    result.Should().BeOfType<TItem[]>();
+    result.Should().BeAssignableTo<IEnumerable<TItem>>();
     result.Should().BeEquivalentTo(expected);
   }
 }