public void generic_type_instance_to_definition_cref()
{
var genericInstanceCRef = new CRefIdentifier("T:Fake.Type{System.Int32}");
var expectedCRef = new CRefIdentifier("T:Fake.Type`1");
var actualCRef = CRefTransformer.FullSimplification.Transform(genericInstanceCRef);
Assert.Equal(expectedCRef, actualCRef);
}
public static void remove_generic_name_parts()
{
var cRef = new CRefIdentifier("M:TestLibrary1.Generic1`2.AMix`1(``1,`0)");
var slug = StaticApiPageGenerator.CreateSlugName(cRef);
slug.Should().StartWith("TestLibrary1.Generic1.AMix-");
}
public static void append_target_type_as_suffix()
{
var cRef = new CRefIdentifier("F:Class1.FieldA");
var slug = StaticApiPageGenerator.CreateSlugName(cRef);
slug.Should().Be("Class1.FieldA-F");
}
public void generic_method_instance_to_definition_cref()
{
var genericInstanceCRef = new CRefIdentifier("M:Fake.Type{System.Int32}.Method{System.String}( Fake.IEnumerable{`0}, ``0)");
var expectedCRef = new CRefIdentifier("M:Fake.Type`1.Method``1( Fake.IEnumerable`1, ``0)");
// NOTE: Whitespace is preserved in the parameters. Good or bad?
var actualCRef = CRefTransformer.FullSimplification.Transform(genericInstanceCRef);
Assert.Equal(expectedCRef, actualCRef);
}
public static void overload_slugs_differ()
{
var cRefA = new CRefIdentifier("M:TestLibrary1.Class1.Inherits.VirtualInstanceMethod(System.Int32)");
var cRefB = new CRefIdentifier("M:TestLibrary1.Class1.Inherits.VirtualInstanceMethod(System.String)");
var slugA = StaticApiPageGenerator.CreateSlugName(cRefA);
var slugB = StaticApiPageGenerator.CreateSlugName(cRefB);
slugA.Should().NotBe(slugB);
}
public void constructor_cref_to_uri_round_trip()
{
var expectedCRef = new CRefIdentifier("!:Fake.#ctor()");
var uri = expectedCRef.ToUri();
CRefIdentifier actualCRef;
Assert.True(CRefIdentifier.TryParse(uri, out actualCRef));
Assert.NotNull(actualCRef);
Assert.Equal(expectedCRef, actualCRef);
}
public void check_generated_uri()
{
var cRef = new CRefIdentifier("!:Fake{Fake.Enumerable{System.Int32}}.Method(``0)");
var uri = cRef.ToUri();
Assert.NotNull(uri);
Assert.Equal("cref",uri.Scheme);
Assert.Equal(
"%21%3AFake%7BFake.Enumerable%7BSystem.Int32%7D%7D.Method%28%60%600%29",
uri.PathAndQuery);
}
public void cref_to_uri_round_trip()
{
var expectedCRef = new CRefIdentifier("!:Fake{Fake.Enumerable{System.Int32}}.Method(``0)");
var uri = expectedCRef.ToUri();
CRefIdentifier actualCRef;
Assert.True(CRefIdentifier.TryParse(uri, out actualCRef));
Assert.NotNull(actualCRef);
Assert.Equal(expectedCRef, actualCRef);
}
/// <summary>
/// Applies a transformation to a code reference.
/// </summary>
/// <param name="cRef">The code reference to transform.</param>
/// <returns>The resulting transformed code reference.</returns>
public CRefIdentifier Transform(CRefIdentifier cRef)
{
if(cRef == null) throw new ArgumentNullException("cRef");
Contract.Ensures(Contract.Result<CRefIdentifier>() != null);
var coreNameParts = CRefIdentifier.ExtractParams(cRef.CoreName, '.');
var hasParamText = !String.IsNullOrWhiteSpace(cRef.ParamPart);
if (coreNameParts.Count > 0) {
var mayBeMethod = String.Equals("M", cRef.TargetType, StringComparison.OrdinalIgnoreCase)
|| (
!String.Equals("T", cRef.TargetType, StringComparison.OrdinalIgnoreCase)
&& hasParamText
);
var lastIndex = coreNameParts.Count - 1;
Contract.Assume(lastIndex >= 0);
if (RemoveArraySuffix && coreNameParts[lastIndex].EndsWith("[]"))
coreNameParts[lastIndex] = coreNameParts[lastIndex].Substring(0, coreNameParts[lastIndex].Length - 2);
if (RemoveRefOutSuffix && coreNameParts[lastIndex].EndsWith("&") || coreNameParts[lastIndex].EndsWith("@"))
coreNameParts[lastIndex] = coreNameParts[lastIndex].Substring(0, coreNameParts[lastIndex].Length - 1);
if (GenericInstanceToDefinition) {
coreNameParts[lastIndex] = NamePartToGenericCardinality(coreNameParts[lastIndex], tickCount: mayBeMethod ? 2 : 1);
for (int i = coreNameParts.Count - 1; i >= 0; i--) {
coreNameParts[i] = NamePartToGenericCardinality(coreNameParts[i]);
}
}
}
var result = String.Join(".", coreNameParts);
if (!String.IsNullOrWhiteSpace(cRef.TargetType))
result = String.Concat(cRef.TargetType, ':', result);
if (hasParamText) {
if (GenericInstanceToDefinition) {
var paramParts = cRef.ParamPartTypes.ConvertAll(t => NamePartToGenericCardinality(t));
result = String.Concat(result, '(', String.Join(",", paramParts), ')');
}
}
return new CRefIdentifier(String.IsNullOrEmpty(result) ? "!:" : result);
}
/// <summary>
/// Creates a namespace from the given name.
/// </summary>
/// <param name="namespaceName">The name of the namespace to create.</param>
/// <returns>A namespace model.</returns>
private CodeDocSimpleMember CreateNamespaceFromName(string namespaceName)
{
Contract.Ensures(Contract.Result<CodeDocSimpleMember>() != null);
string namespaceFriendlyName;
if (String.IsNullOrWhiteSpace(namespaceName)) {
namespaceName = String.Empty;
namespaceFriendlyName = "global";
}
else {
namespaceFriendlyName = namespaceName;
}
var cRef = new CRefIdentifier("N:" + namespaceName);
return new CodeDocSimpleMember(cRef) {
Uri = cRef.ToUri(),
FullName = namespaceFriendlyName,
ShortName = namespaceFriendlyName,
SubTitle = "Namespace",
Title = namespaceFriendlyName,
ExternalVisibility = ExternalVisibilityKind.Public
};
}
/// <summary>
/// Gets a type model for the given code reference or creates a new one.
/// </summary>
/// <param name="cRef">The code reference to get a model for.</param>
/// <param name="detailLevel">Indicates the desired detail level of the generated model.</param>
/// <returns>A code doc model for the given code reference.</returns>
protected CodeDocType GetOrConvertType(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
Contract.Ensures(Contract.Result<ICodeDocMember>() != null);
return ToTypeModel(GetOrConvert(cRef, detailLevel));
}
/// <summary>
/// Gets a model for the given code reference or creates a new one.
/// </summary>
/// <param name="cRef">The code reference to get a model for.</param>
/// <param name="detailLevel">Indicates the desired detail level of the generated model.</param>
/// <returns>A code doc model for the given code reference.</returns>
protected ICodeDocMember GetOrConvert(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
Contract.Ensures(Contract.Result<ICodeDocMember>() != null);
return GetOnly(cRef, detailLevel)
?? CreateGeneralMemberPlaceholder(cRef);
}
protected CodeDocType GetOnlyType(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
return ToTypeModel(GetOnly(cRef, detailLevel));
}
protected CodeDocProperty GetOnlyProperty(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
return ToPropertyModel(GetOnly(cRef, detailLevel));
}
/// <summary>
/// Constructor for a code doc member model.
/// </summary>
/// <param name="cRef">The code reference of this member.</param>
protected CodeDocMemberContentBase(CRefIdentifier cRef)
: base(cRef)
{
Contract.Requires(cRef != null);
}
/// <summary>
/// Gets a namespace model by code reference.
/// </summary>
/// <param name="cRef">The code reference.</param>
/// <returns>A namespace model if found.</returns>
protected CodeDocSimpleNamespace GetCodeDocSimpleNamespace(CRefIdentifier cRef)
{
Contract.Requires(cRef != null);
return Repository.Namespaces.FirstOrDefault(x => cRef.Equals(x.CRef));
}
/// <summary>
/// Creates a code doc placeholder model for a given code reference.
/// </summary>
/// <param name="cRef">The code reference to construct a model for.</param>
/// <returns>A code model representing the given code reference.</returns>
protected ICodeDocMember CreateGeneralMemberPlaceholder(CRefIdentifier cRef)
{
Contract.Requires(cRef != null);
Contract.Ensures(Contract.Result<ICodeDocMember>() != null);
string subTitle;
if ("T".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
subTitle = "Type";
else if ("M".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
subTitle = "Invokable";
else if ("P".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
subTitle = "Property";
else if ("E".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
subTitle = "Event";
else if ("F".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
subTitle = "Field";
else if ("N".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
subTitle = "Namespace";
else if ("A".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
subTitle = "Assembly";
else
subTitle = String.Empty;
var cRefFullName = cRef.CoreName;
return new CodeDocSimpleMember(cRef) {
Uri = cRef.ToUri(),
ShortName = cRefFullName,
Title = cRefFullName,
SubTitle = subTitle,
FullName = cRefFullName,
NamespaceName = String.Empty,
ExternalVisibility = ExternalVisibilityKind.Public
};
}
/// <summary> /// Creates a member model for the given code reference. /// </summary> /// <param name="cRef">The code reference to generate a model for.</param> /// <param name="detailLevel">Indicates the desired detail level of the generated model.</param> /// <returns>The generated member if possible.</returns> public abstract ICodeDocMember GetMemberModel(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel);
/// <summary>
/// Gets an assembly model by code reference.
/// </summary>
/// <param name="cRef">The code reference.</param>
/// <returns>An assembly model if found.</returns>
public CodeDocSimpleAssembly GetCodeDocSimpleAssembly(CRefIdentifier cRef)
{
Contract.Requires(cRef != null);
var assemblies = Repository.Assemblies;
return assemblies.FirstOrDefault(x => cRef.Equals(x.CRef))
?? assemblies.FirstOrDefault(x => cRef.CoreName == x.AssemblyFileName)
?? assemblies.FirstOrDefault(x => cRef.CoreName == x.ShortName);
}
/// <summary>
/// Creates a new code doc namespace model.
/// </summary>
/// <param name="cRef">The namespace code reference.</param>
public CodeDocNamespace(CRefIdentifier cRef)
: base(cRef)
{
Contract.Requires(cRef != null);
}
/// <summary>
/// Creates a new assembly with the given cRef identifier.
/// </summary>
/// <param name="cRef">The assembly code reference.</param>
/// <remarks>
/// Assembly code references should be prefixed with 'A:' followed by the assembly short name or full name.
/// </remarks>
public CodeDocSimpleAssembly(CRefIdentifier cRef)
: base(cRef)
{
Contract.Requires(cRef != null);
}
/// <summary>
/// Creates a member model for the given code reference.
/// </summary>
/// <param name="cRef">The code reference to generate a model for.</param>
/// <param name="searchContext">The serach context to use when locating related members.</param>
/// <param name="detailLevel">Indicates the desired detail level of the generated model.</param>
/// <returns>The generated member if possible.</returns>
public virtual ICodeDocMember GetMemberModel(CRefIdentifier cRef, CodeDocRepositorySearchContext searchContext = null, CodeDocMemberDetailLevel detailLevel = CodeDocMemberDetailLevel.Full)
{
return CreateGenerator(searchContext).GetMemberModel(cRef, detailLevel);
}
/// <summary>
/// Creates a new model for a delegate member.
/// </summary>
/// <param name="cRef">The code reference of this member.</param>
public CodeDocDelegate(CRefIdentifier cRef)
: base(cRef)
{
Contract.Requires(cRef != null);
}
/// <summary>
/// Gets a URI that links to or identifies a given member.
/// </summary>
/// <param name="memberInfo">The member to get a URI for.</param>
/// <returns>A URI representing the given member.</returns>
protected virtual Uri GetUri(MemberInfo memberInfo)
{
if (memberInfo == null)
return null;
if (memberInfo is Type) {
var type = memberInfo as Type;
if (type.IsGenericType && !type.IsGenericTypeDefinition)
memberInfo = type.GetGenericTypeDefinition();
}
else if (memberInfo is MethodInfo) {
var methodInfo = memberInfo as MethodInfo;
if (methodInfo.IsGenericMethod && !methodInfo.IsGenericMethodDefinition)
memberInfo = methodInfo.GetGenericMethodDefinition();
}
var cRef = GetGenericDefinitionCRefIdentifier(memberInfo);
if(cRef.TargetType == "T"){
if(cRef.FullCRef.EndsWith("&") || cRef.FullCRef.EndsWith("@"))
cRef = new CRefIdentifier(cRef.FullCRef.Substring(0,cRef.FullCRef.Length-1));
if(cRef.FullCRef.EndsWith("]")){
var lastOpenSquareBracket = cRef.FullCRef.LastIndexOf('[');
if(lastOpenSquareBracket >= 0) {
var toLastSquareBracket = cRef.FullCRef.Substring(0, lastOpenSquareBracket);
Contract.Assume(!String.IsNullOrEmpty(toLastSquareBracket));
cRef = new CRefIdentifier(toLastSquareBracket);
}
}
}
return cRef.ToUri();
}
protected ICodeDocMember GetOnly(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
if(HasSearchContext){
var searchContext = SearchContext.CloneWithoutVisits(detailLevel);
var searchResult = searchContext.Search(cRef);
if (searchResult != null)
return searchResult;
}
if (!HasSearchContext || !SearchContext.IsReferenced(Repository)) {
var localModel = GetMemberModel(cRef, detailLevel);
if (localModel != null)
return localModel;
}
return null;
}
/// <summary>
/// Gets a code doc model for a reflected member.
/// </summary>
/// <param name="cRef">The code reference of a reflected member to create a model from.</param>
/// <param name="detailLevel">Indicates the desired detail level of the model.</param>
/// <returns>A code doc model.</returns>
public override ICodeDocMember GetMemberModel(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
if (cRef == null) throw new ArgumentNullException("cRef");
Contract.EndContractBlock();
if ("N".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
return ToFullNamespace(GetCodeDocSimpleNamespace(cRef));
if ("A".Equals(cRef.TargetType, StringComparison.OrdinalIgnoreCase))
return GetCodeDocSimpleAssembly(cRef);
var memberInfo = ReflectionRepository.CRefLookup.GetMember(cRef);
if (memberInfo == null || !ReflectionRepository.MemberFilter(memberInfo))
return null;
return ConvertToModel(memberInfo, detailLevel);
}
public void extract_return_type()
{
var cRef = new CRefIdentifier("M:Some.Method(Some.ParamType)~System.String");
Assert.Equal("System.String", cRef.ReturnTypePart);
}
protected CodeDocMethod GetOnlyMethod(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
return ToMethodModel(GetOnly(cRef, detailLevel));
}
protected CodeDocEvent GetOnlyEvent(CRefIdentifier cRef, CodeDocMemberDetailLevel detailLevel)
{
Contract.Requires(cRef != null);
return ToEventModel(GetOnly(cRef, detailLevel));
}
/// <summary>
/// Performs a search using this search context for a code doc member model.
/// </summary>
/// <param name="cRef">The code reference to search for.</param>
/// <returns>The first member model that is found, null otherwise.</returns>
public ICodeDocMember Search(CRefIdentifier cRef)
{
ICodeDocMemberRepository repository;
while((repository = PopUnvisitedRepository()) != null){
var model = repository.GetMemberModel(cRef, this, DetailLevel);
if (model != null)
return model;
}
return null;
}
