Skip to content

Commit

Permalink
Remove MD renderer factory and related markdown renderers. (#3599)
Browse files Browse the repository at this point in the history 
* Remove MD renderer factory and related markdown renderers.

* Remove record type field renderer.
  • Loading branch information
@kallentu
kallentu authored Dec 11, 2023
1 parent 9fd64a2 commit 7ac2a1c
Show file tree
Hide file tree
Showing 16 changed files with 0 additions and 620 deletions.
45 changes: 0 additions & 45 deletions lib/src/generator/markdown_generator.dart
View file

This file was deleted.

80 changes: 0 additions & 80 deletions lib/src/generator/templates.dart
View file
Original file line number Diff line number Diff line change
Expand Up @@ -46,8 +46,6 @@ import 'package:dartdoc/src/generator/resource_loader.dart';
import 'package:dartdoc/src/generator/template_data.dart';
import 'package:dartdoc/src/generator/templates.aot_renderers_for_html.dart'
as aot_renderers_for_html;
import 'package:dartdoc/src/generator/templates.aot_renderers_for_md.dart'
as aot_renderers_for_md;
import 'package:dartdoc/src/generator/templates.runtime_renderers.dart'
as runtime_renderers;
import 'package:dartdoc/src/model/annotation.dart';
Expand Down Expand Up @@ -211,84 +209,6 @@ class HtmlAotTemplates implements Templates {
aot_renderers_for_html.renderTypedef(context);
}

/// The [Templates] implementation which uses the render functions generated
/// from the default Dartdoc Markdown templates.
class MarkdownAotTemplates implements Templates {
@override
String renderCategory(CategoryTemplateData context) =>
aot_renderers_for_md.renderCategory(context);

@override
String renderClass<T extends Class>(ClassTemplateData context) =>
aot_renderers_for_md.renderClass(context);

@override
String renderConstructor(ConstructorTemplateData context) =>
aot_renderers_for_md.renderConstructor(context);

@override
String renderEnum(EnumTemplateData context) =>
aot_renderers_for_md.renderEnum(context);

@override
String renderError(PackageTemplateData context) =>
aot_renderers_for_md.renderError();

@override
String renderExtension(ExtensionTemplateData context) =>
aot_renderers_for_md.renderExtension(context);

@override
String renderExtensionType(ExtensionTypeTemplateData context) =>
aot_renderers_for_md.renderExtensionType(context);

@override
String renderFunction(FunctionTemplateData context) =>
aot_renderers_for_md.renderFunction(context);

@override
String renderIndex(PackageTemplateData context) =>
aot_renderers_for_md.renderIndex(context);

@override
String renderLibrary(LibraryTemplateData context) =>
aot_renderers_for_md.renderLibrary(context);

@override
String renderMethod(MethodTemplateData context) =>
aot_renderers_for_md.renderMethod(context);

@override
String renderMixin(MixinTemplateData context) =>
aot_renderers_for_md.renderMixin(context);

@override
String renderProperty(PropertyTemplateData context) =>
aot_renderers_for_md.renderProperty(context);

@override
String renderSearchPage(PackageTemplateData context) =>
aot_renderers_for_md.renderSearchPage(context);

@override
String renderSidebarForContainer(
TemplateDataWithContainer<Documentable> context) =>
aot_renderers_for_md.renderSidebarForContainer();

@override
String renderSidebarForLibrary(
TemplateDataWithLibrary<Documentable> context) =>
aot_renderers_for_md.renderSidebarForLibrary();

@override
String renderTopLevelProperty(TopLevelPropertyTemplateData context) =>
aot_renderers_for_md.renderTopLevelProperty(context);

@override
String renderTypedef(TypedefTemplateData context) =>
aot_renderers_for_md.renderTypedef(context);
}

/// The collection of [Template] objects parsed at runtime.
class RuntimeTemplates implements Templates {
@override
Expand Down
9 changes: 0 additions & 9 deletions lib/src/render/attribute_renderer.dart
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,12 +28,3 @@ class AttributeRendererHtml extends AttributeRenderer {
String renderAnnotation(Annotation attribute) =>
'@${attribute.linkedName}${_htmlEscape.convert(attribute.parameterText)}';
}

/// A Markdown renderer for an [Attribute].
class AttributeRendererMd extends AttributeRenderer {
const AttributeRendererMd();

@override
String renderAnnotation(Annotation attribute) =>
'@${attribute.linkedName}${_htmlEscape.convert(attribute.parameterText)}';
}
17 changes: 0 additions & 17 deletions lib/src/render/category_renderer.dart
View file
Original file line number Diff line number Diff line change
Expand Up @@ -53,20 +53,3 @@ class CategoryRendererHtml implements CategoryRenderer {
}
}
}

/// A markdown renderer for a [Category].
class CategoryRendererMd implements CategoryRenderer {
const CategoryRendererMd();

@override
String renderCategoryLabel(Category category) => renderLinkedName(category);

@override
String renderLinkedName(Category category) {
final name = category.name;
if (category.isDocumented) {
return '[$name](${category.href})';
}
return name;
}
}
181 changes: 0 additions & 181 deletions lib/src/render/element_type_renderer.dart
View file
Original file line number Diff line number Diff line change
Expand Up @@ -207,184 +207,3 @@ class CallableElementTypeRendererHtml
return buffer.toString();
}
}

// Markdown implementations.

abstract class ElementTypeRendererMd<T extends ElementType>
extends ElementTypeRenderer<T> {
const ElementTypeRendererMd();

String _renderLinkedName(
T elementType, String name, Iterable<ElementType> typeArguments) {
var buffer = StringBuffer()..write(name);
if (typeArguments.isNotEmpty &&
!typeArguments.every((t) => t.name == 'dynamic')) {
buffer
..write('&lt;')
..writeAll(typeArguments.map((t) => t.linkedName), ', ')
..write('>');
}
buffer.write(elementType.nullabilitySuffix);
return buffer.toString();
}

String _renderNameWithGenerics(
T elementType, String name, Iterable<ElementType> typeArguments) {
var buffer = StringBuffer()..write(name);
if (typeArguments.isNotEmpty &&
!typeArguments.every((t) => t.name == 'dynamic')) {
buffer
..write('&lt;')
..writeAll(typeArguments.map((t) => t.nameWithGenerics), ', ')
..write('>');
}
buffer.write(elementType.nullabilitySuffix);
return buffer.toString();
}
}

class FunctionTypeElementTypeRendererMd
extends ElementTypeRenderer<FunctionTypeElementType> {
const FunctionTypeElementTypeRendererMd();

@override
String renderLinkedName(FunctionTypeElementType elementType) {
var parameterRenderer = const ParameterRendererMd();
return wrapNullabilityParens(
elementType,
'${elementType.returnType.linkedName} '
'${elementType.nameWithGenerics}'
'('
'${parameterRenderer.renderLinkedParams(elementType.parameters)}'
')');
}

@override
String renderNameWithGenerics(FunctionTypeElementType elementType) {
var buffer = StringBuffer()..write(elementType.name);
if (elementType.typeFormals.isNotEmpty) {
if (!elementType.typeFormals.every((t) => t.name == 'dynamic')) {
buffer
..write('&lt;')
..writeAll(elementType.typeFormals.map((t) => t.name), ', ')
..write('>');
}
}
return buffer.toString();
}
}

class ParameterizedElementTypeRendererMd
extends ElementTypeRendererMd<ParameterizedElementType> {
const ParameterizedElementTypeRendererMd();

@override
String renderLinkedName(ParameterizedElementType elementType) =>
_renderLinkedName(
elementType,
elementType.modelElement.linkedName,
elementType.typeArguments,
);

@override
String renderNameWithGenerics(ParameterizedElementType elementType) =>
_renderNameWithGenerics(
elementType,
elementType.modelElement.name,
elementType.typeArguments,
);
}

class RecordElementTypeRendererMd
extends ElementTypeRendererMd<RecordElementType> {
const RecordElementTypeRendererMd();

@override
String renderLinkedName(RecordElementType elementType) {
var buffer = StringBuffer()
..write('(')
..write(
const RecordTypeFieldListMdRenderer().renderLinkedFields(elementType))
..write(')');
return wrapNullabilityParens(elementType, buffer.toString());
}

@override
String renderNameWithGenerics(RecordElementType elementType) {
return '${elementType.name}${elementType.nullabilitySuffix}';
}
}

class AliasedElementTypeRendererMd
extends ElementTypeRendererMd<AliasedElementType> {
const AliasedElementTypeRendererMd();

@override
String renderLinkedName(AliasedElementType elementType) => _renderLinkedName(
elementType,
elementType.aliasElement.linkedName,
elementType.aliasArguments,
);

@override
String renderNameWithGenerics(AliasedElementType elementType) =>
_renderNameWithGenerics(
elementType,
elementType.aliasElement.name,
elementType.aliasArguments,
);
}

class AliasedUndefinedElementTypeRendererMd
extends ElementTypeRendererMd<AliasedUndefinedElementType> {
const AliasedUndefinedElementTypeRendererMd();

@override
String renderLinkedName(AliasedUndefinedElementType elementType) =>
_renderLinkedName(
elementType,
elementType.aliasElement.linkedName,
elementType.aliasArguments,
);

@override
String renderNameWithGenerics(AliasedUndefinedElementType elementType) =>
_renderNameWithGenerics(
elementType,
elementType.aliasElement.name,
elementType.aliasArguments,
);
}

class CallableElementTypeRendererMd
extends ElementTypeRendererMd<CallableElementType> {
const CallableElementTypeRendererMd();

@override
String renderLinkedName(CallableElementType elementType) {
var buffer = StringBuffer()
..write(elementType.nameWithGenerics)
..write('(')
..write(const ParameterRendererMd()
.renderLinkedParams(elementType.parameters, showNames: false)
.trim())
..write(') → ')
..write(elementType.returnType.linkedName);
return wrapNullabilityParens(elementType, buffer.toString());
}

@override
String renderNameWithGenerics(CallableElementType elementType) {
var buffer = StringBuffer()..write(elementType.name);
if (elementType.typeArguments.isNotEmpty &&
!elementType.typeArguments.every((t) => t.name == 'dynamic')) {
buffer
..write('&lt;')
..writeAll(
elementType.typeArguments.map((t) => t.nameWithGenerics), ', ')
..write('>');
}
buffer.write(elementType.nullabilitySuffix);
return buffer.toString();
}
}
21 changes: 0 additions & 21 deletions lib/src/render/enum_field_renderer.dart
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,24 +30,3 @@ class EnumFieldRendererHtml implements EnumFieldRenderer {
return '<a$cssClass href="${field.href}#${field.htmlId}">${field.name}</a>';
}
}

class EnumFieldRendererMd implements EnumFieldRenderer {
const EnumFieldRendererMd();

@override
String renderValue(EnumField field) {
if (field.name == 'values') {
return 'const List&lt;${field.enclosingElement.name}>';
} else {
return 'const ${field.enclosingElement.name}(${field.index})';
}
}

@override
String renderLinkedName(EnumField field) {
if (field.isDeprecated) {
return '[~~${field.name}~~](${field.href})';
}
return '[${field.name}](${field.href})';
}
}
Loading

0 comments on commit 7ac2a1c

Please sign in to comment.