Add recipe descriptor

Signed-off-by: OlegDokuka <[email protected]>

Author: OlegDokuka

Rewrite/Directory.Build.props

@@ -3,9 +3,9 @@
         <Company>Moderne Inc.</Company>
         <PackageIcon>openrewrite.png</PackageIcon>
         <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
-        <Version>0.8.0-preview-5</Version>
+        <Version>0.8.0-preview-6</Version>
 
-        <RewriteRemoteVersion>0.8.0-preview-4</RewriteRemoteVersion>
+        <RewriteRemoteVersion>0.8.0-preview-5</RewriteRemoteVersion>
         <RewriteRemoteDir Condition="'$(RewriteRemoteDir)'==''">..\..\..\..\..\moderneinc\rewrite-remote\Rewrite.Remote</RewriteRemoteDir>
     </PropertyGroup>
 </Project>

Rewrite/src/Rewrite.Core/Config/OptionAttribute.cs

@@ -0,0 +1,7 @@
+namespace Rewrite.Core;
+
+[AttributeUsage(AttributeTargets.Field)]
+public sealed class OptionAttribute : Attribute
+{
+    
+}

Rewrite/src/Rewrite.Core/Config/OptionDescriptor.cs

@@ -0,0 +1,58 @@
+namespace Rewrite.Core.Config;
+
+public class OptionDescriptor
+{
+    // Properties with public getters and private setters for immutability
+    public string Name { get; }
+    public string Type { get; }
+    public string? DisplayName { get; }
+    public string? Description { get; }
+    public string? Example { get; }
+    public List<string>? Valid { get; }
+    public bool Required { get; }
+    public object? Value { get; }
+
+    // Constructor to initialize the properties
+    public OptionDescriptor(
+        string name,
+        string type,
+        string? displayName,
+        string? description,
+        string? example,
+        List<string>? valid,
+        bool required,
+        object? value)
+    {
+        Name = name;
+        Type = type;
+        DisplayName = displayName;
+        Description = description;
+        Example = example;
+        Valid = valid;
+        Required = required;
+        Value = value;
+    }
+
+    // Override Equals and GetHashCode to handle equality based on Name, Type, and Value
+    public override bool Equals(object? obj)
+    {
+        if (obj is OptionDescriptor other)
+        {
+            return Name == other.Name &&
+                   Type == other.Type &&
+                   DisplayName == other.DisplayName &&
+                   Description == other.Description &&
+                   Example == other.Example &&
+                   Valid?.SequenceEqual(other.Valid) == true &&
+                   Required == other.Required &&
+                   Equals(Value, other.Value);
+        }
+
+        return false;
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(Name, Type, DisplayName, Description, Example, Valid, Required, Value);
+    }
+}

Rewrite/src/Rewrite.Core/Config/RecipeDescriptor.cs

@@ -0,0 +1,89 @@
+namespace Rewrite.Core.Config;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class RecipeDescriptor
+{
+    // Properties with public getters and private setters to maintain immutability
+    public string Name { get; }
+    public string DisplayName { get; }
+    public string Description { get; }
+    public HashSet<string> Tags { get; }
+    public TimeSpan? EstimatedEffortPerOccurrence { get; }
+    public List<OptionDescriptor> Options { get; }
+    public List<RecipeDescriptor> RecipeList { get; }
+    // public List<DataTableDescriptor> DataTables { get; }
+    // public List<Maintainer> Maintainers { get; }
+    // public List<Contributor> Contributors { get; }
+    // public List<RecipeExample> Examples { get; }
+    public Uri Source { get; }
+
+    // Constructor to initialize the properties
+    public RecipeDescriptor(string name, string displayName, string description, HashSet<string> tags,
+        TimeSpan? estimatedEffortPerOccurrence, List<OptionDescriptor> options, List<RecipeDescriptor> recipeList,
+        /*List<DataTableDescriptor> dataTables, List<Maintainer> maintainers, List<Contributor> contributors,
+        List<RecipeExample> examples,*/ Uri source)
+    {
+        Name = name;
+        DisplayName = displayName;
+        Description = description;
+        Tags = tags;
+        EstimatedEffortPerOccurrence = estimatedEffortPerOccurrence;
+        Options = options;
+        RecipeList = recipeList;
+        // DataTables = dataTables;
+        // Maintainers = maintainers;
+        // Contributors = contributors;
+        // Examples = examples;
+        Source = source;
+    }
+
+    // Override Equals and GetHashCode to handle equality based on Name and Options
+    public override bool Equals(object obj)
+    {
+        if (obj is RecipeDescriptor other)
+        {
+            return Name == other.Name && Options.SequenceEqual(other.Options);
+        }
+
+        return false;
+    }
+
+    public override int GetHashCode()
+    {
+        return (Name, Options).GetHashCode();
+    }
+
+    // With pattern for immutability
+    public RecipeDescriptor With(
+        string name = null,
+        string displayName = null,
+        string description = null,
+        HashSet<string> tags = null,
+        TimeSpan? estimatedEffortPerOccurrence = null,
+        List<OptionDescriptor> options = null,
+        List<RecipeDescriptor> recipeList = null,
+        // List<DataTableDescriptor> dataTables = null,
+        // List<Maintainer> maintainers = null,
+        // List<Contributor> contributors = null,
+        // List<RecipeExample> examples = null,
+        Uri source = null)
+    {
+        return new RecipeDescriptor(
+            name ?? this.Name,
+            displayName ?? this.DisplayName,
+            description ?? this.Description,
+            tags ?? this.Tags,
+            estimatedEffortPerOccurrence ?? this.EstimatedEffortPerOccurrence,
+            options ?? this.Options,
+            recipeList ?? this.RecipeList,
+            // dataTables ?? this.DataTables,
+            // maintainers ?? this.Maintainers,
+            // contributors ?? this.Contributors,
+            // examples ?? this.Examples,
+            source ?? this.Source
+        );
+    }
+}

Rewrite/src/Rewrite.Core/Recipe.cs

@@ -1,7 +1,38 @@
+using System.Runtime.CompilerServices;
+using Rewrite.Core.Config;
+
 namespace Rewrite.Core;
 
 public abstract class Recipe
 {
+    private RecipeDescriptor? _descriptor;
+
+    public RecipeDescriptor Descriptor
+    {
+        get
+        {
+            return _descriptor ?? (_descriptor = new RecipeDescriptor(GetType().FullName, GetType().FullName, "",
+                new HashSet<string>(), null,
+                GetType().GetConstructors()[0].GetParameters().Select(parameterInfo =>
+                {
+                    return new OptionDescriptor(parameterInfo.Name, parameterInfo.ParameterType.FullName, null,
+                        null,
+                        null,
+                        null,
+                        !(parameterInfo.IsOptional || parameterInfo.HasDefaultValue ||
+                          parameterInfo.CustomAttributes.FirstOrDefault(data =>
+                              data.AttributeType == typeof(NullableAttribute)) != null),
+                        parameterInfo.DefaultValue
+                    );
+                }).ToList(),
+                [],
+                new Uri($"recipe://{GetType().FullName}")
+            ));
+        }
+
+        set => _descriptor = value;
+    }
+
     public static Recipe Noop()
     {
         return new NoopRecipe();

Rewrite/tests/Rewrite.CSharp.Tests/Tree/NullSafeExpressionTests.cs

@@ -8,7 +8,7 @@ namespace Rewrite.CSharp.Tests.Tree;
 [Collection("C# remoting")]
 public class NullSafeExpressionTests : RewriteTest
 {
-    [Fact(Skip = "NullSafeExpression parsing was disabled due to infiti recursion issue")]
+    [Fact(Skip = "NullSafeExpression parsing was disabled due to infinite recursion issue")]
     public void Space()
     {
         RewriteRun(