Make GitObject.Repository public

[SimonCropp]

It would be great if GitObject.Repository was made public
https://github.com/libgit2/libgit2sharp/blob/vNext/LibGit2Sharp/GitObject.cs#L31

I have many extension methods that need access to both the GitObject (eg a Commit) and the Repository. At the moment I need to pass in the instance of the repository or access it via reflection.

[SimonCropp]

happy to do a PR :)

[nulltoken]

It would be great if GitObject.Repository was made public
happy to do a PR :)

Thanks a lot for this proposal! However, I'm afraid that this would go against the "style" of the API.

Having GitObject bear a pointer to the Repository is only an implementation detail. As such, I'd prefer to not expose it.

[dahlbyk]

I'm curious what kind of extension methods depend on the Repository - are they useful enough to include in their own right?

[SimonCropp]

@dahlbyk for example

    public static IEnumerable<Tag> TagsByDate(this IRepository repository, Commit commit)
    {
        return repository.Tags
            .Where(tag => tag.Target == commit)
            .OrderByDescending(tag =>
            {
                if (tag.Annotation != null)
                {
                    return tag.Annotation.Tagger.When;
                }
                //lightweight tags will not have an Annotation
                return commit.Committer.When;
            });
    }

@nulltoken perhaps we can compromise and have Repository be public but hidden

/// <summary>
/// The <see cref="Repository"/> containing the object. 
/// Only made public for advanced usage scenarios. 
/// Should not be considered a public API and may change in any minor release.
/// </summary>
[EditorBrowsable(EditorBrowsableState.Advanced)]
public readonly Repository repo;

[SimonCropp]

@dahlbyk in my example it would be much more elegant if i could

    public static IEnumerable<Tag> TagsByDate(this Commit commit)
    {
        return commit.Repository.Tags
            .Where(tag => tag.Target == commit)
            .OrderByDescending(tag =>
            {
                if (tag.Annotation != null)
                {
                    return tag.Annotation.Tagger.When;
                }
                //lightweight tags will not have an Annotation
                return commit.Committer.When;
            });
    }

[nulltoken]

@nulltoken perhaps we can compromise and have Repository be public but hidden

That's CHEATING! 😉 More seriously, "Hidden" still makes it part of the public API, only harder to find.

How about this?

diff --git a/GitFlowVersion/LibGitExtensions.cs b/GitFlowVersion/LibGitExtensions.cs
index b766f96..9748dd9 100644
--- a/GitFlowVersion/LibGitExtensions.cs
+++ b/GitFlowVersion/LibGitExtensions.cs
@@ -3,10 +3,24 @@ namespace GitFlowVersion
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Linq.Expressions;
     using LibGit2Sharp;

     static class LibGitExtensions
     {
+        private static readonly Func<GitObject, object> repositoryAccessor;
+
+        static LibGitExtensions()
+        {
+            ParameterExpression arg = Expression.Parameter(typeof(GitObject), "x");
+            Expression expr = Expression.Field(arg, "repo");
+            repositoryAccessor = Expression.Lambda<Func<GitObject, object>>(expr, arg).Compile();
+        }
+
+        public static IRepository Repository(this GitObject obj)
+        {
+            return (IRepository)repositoryAccessor(obj);
+        }

         public static DateTimeOffset When(this Commit commit)
         {
@@ -22,9 +36,9 @@ public static string Prefix(this Commit commit)
             return commit.Sha.Substring(0, 8);
         }

-        public static SemanticVersion NewestSemVerTag(this IRepository repository, Commit commit)
+        public static SemanticVersion NewestSemVerTag(Commit commit)
         {
-            foreach (var tag in repository.TagsByDate(commit))
+            foreach (var tag in commit.TagsByDate())
             {
                 SemanticVersion version;
                 if (SemanticVersionParser.TryParse(tag.Name, out version))
@@ -35,9 +49,9 @@ public static SemanticVersion NewestSemVerTag(this IRepository repository, Commi
             return null;
         }

-        public static IEnumerable<Tag> TagsByDate(this IRepository repository, Commit commit)
+        public static IEnumerable<Tag> TagsByDate(this Commit commit)
         {
-            return repository.Tags
+            return commit.Repository().Tags
                 .Where(tag => tag.Target == commit)
                 .OrderByDescending(tag =>
                 {

[dahlbyk]

Needing to depend on the repo field never changing = sad.

Another option would be to define an interface that chosen types could explicitly implement...

public interface IBelongToARepository
{
    IRepository Repository { get; }
}

It would not be part of the normally-visible public API, but still available without reflection to those that require it.

[nulltoken]

Needing to depend on the repo field never changing = sad.

My proposal wouldn't be officially supported either. It's nothing more than a hack. And indeed a fragile one. This will stop working without prior notice.

I'm not in favor of exposing properties with a wider scope than the object itself. From the consumer perspective, I'd rather keep the objects as dumb and self-contained as possible.

[nulltoken]

Closing this now.

Cheers!

[dahlbyk]

It would not be part of the normally-visible public API, but still available without reflection to those that require it.

FWIW, I can still see merit in defining some sort of interface for objects that have an internal dependency on an IRepository, both as a way to document "hey, you shouldn't use me after you've disposed my repo" and to support this kind of use case.

[nulltoken]

@SimonCropp See #665. I have been gently @dahlbyk'd and this may now be happening. 😉

[SimonCropp]

@nulltoken awesome. will allow me to remove some reflection