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; }