marktwin 0.5.0

Marktwin format support for Eternaltwin.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::borrow::Cow;

/// Describes all the elements of a syntax.
pub trait Syntax: Sized {
  type Root: Root<Ast = Self>;

  type Block: Block<Ast = Self>;
  type Admin: Admin<Ast = Self>;
  type Mod: Mod<Ast = Self>;

  type Inline: Inline<Ast = Self>;
  type Emphasis: Emphasis<Ast = Self>;
  type Icon: Icon<Ast = Self>;
  type Link: Link<Ast = Self>;
  type Newline: Newline;
  type Strikethrough: Strikethrough<Ast = Self>;
  type Strong: Strong<Ast = Self>;
  type Text: Text<Ast = Self>;
}

/// A `Cow` variant that does not require `ToOwned`.
///
/// It is intended as a workaround until Generic Associated Types are improved.
/// Once rust-lang/rust#30472 is fixed, this type could be removed.
#[derive(Debug)]
pub enum MaybeOwned<'a, T>
where
  T: 'a,
{
  Borrowed(&'a T),
  Owned(T),
}

impl<T> std::ops::Deref for MaybeOwned<'_, T> {
  type Target = T;
  fn deref(&self) -> &T {
    match self {
      MaybeOwned::Borrowed(borrowed) => borrowed,
      MaybeOwned::Owned(ref owned) => owned,
    }
  }
}

/// Trait representing a container for block and inline nodes.
pub trait BlockContainer {
  type Ast: Syntax;

  fn children<'a>(&'a self) -> Box<dyn Iterator<Item = MaybeOwned<'a, <Self::Ast as Syntax>::Block>> + 'a>;
}

/// Trait representing a container for inline nodes.
pub trait InlineContainer {
  type Ast: Syntax;

  fn children<'a>(&'a self) -> Box<dyn Iterator<Item = MaybeOwned<'a, <Self::Ast as Syntax>::Inline>> + 'a>;
}

/// Message root node
pub trait Root: BlockContainer {
  type Ast: Syntax;
}

/// Trait representing any block or inline node
pub trait Block {
  type Ast: Syntax;

  /// Downcast the statement to its concrete type.
  fn cast(&self) -> BlockCast<Self::Ast>;
}

/// Represents the result of downcasting a block or inline node.
pub enum BlockCast<'a, S: Syntax> {
  Admin(MaybeOwned<'a, S::Admin>),
  Mod(MaybeOwned<'a, S::Mod>),
  // Inline nodes
  Emphasis(MaybeOwned<'a, S::Emphasis>),
  Icon(MaybeOwned<'a, S::Icon>),
  Link(MaybeOwned<'a, S::Link>),
  Newline(MaybeOwned<'a, S::Newline>),
  Strikethrough(MaybeOwned<'a, S::Strikethrough>),
  Strong(MaybeOwned<'a, S::Strong>),
  Text(MaybeOwned<'a, S::Text>),
}

/// Admin block
pub trait Admin: BlockContainer {
  type Ast: Syntax;
}

/// Mod block
pub trait Mod: BlockContainer {
  type Ast: Syntax;
}

/// Trait representing any inline node
pub trait Inline {
  type Ast: Syntax;

  /// Downcast the statement to its concrete type.
  fn cast(&self) -> InlineCast<Self::Ast>;
}

/// Represents the result of downcasting an inline node.
pub enum InlineCast<'a, S: Syntax> {
  Emphasis(MaybeOwned<'a, S::Emphasis>),
  Icon(MaybeOwned<'a, S::Icon>),
  Link(MaybeOwned<'a, S::Link>),
  Newline(MaybeOwned<'a, S::Newline>),
  Strikethrough(MaybeOwned<'a, S::Strikethrough>),
  Strong(MaybeOwned<'a, S::Strong>),
  Text(MaybeOwned<'a, S::Text>),
}

/// Emphasis span
pub trait Emphasis: InlineContainer {
  type Ast: Syntax;
}

pub trait Icon {
  type Ast: Syntax;

  fn key(&self) -> Cow<str>;
}

pub trait Link: InlineContainer {
  type Ast: Syntax;

  fn uri(&self) -> Cow<str>;
}

pub trait Newline {}

pub trait Strikethrough: InlineContainer {
  type Ast: Syntax;
}

/// Strong span
pub trait Strong: InlineContainer {
  type Ast: Syntax;
}

pub trait Text {
  type Ast: Syntax;

  fn text(&self) -> Cow<str>;
}