First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
require "../spec_helper"
|
|
|
|
|
|
|
|
|
|
include Nodes
|
|
|
|
|
|
|
|
|
|
describe PageContent do
|
|
|
|
|
it "renders a single parent/child node structure" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Paragraph.new(children: [
|
|
|
|
|
Text.new(content: "hi"),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<p>hi</p>)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders multiple childrens" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Paragraph.new(children: [
|
|
|
|
|
Text.new(content: "Hello, "),
|
|
|
|
|
Emphasis.new(children: [
|
|
|
|
|
Text.new(content: "World!"),
|
|
|
|
|
] of Child),
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
] of Child),
|
2021-08-14 23:36:10 +02:00
|
|
|
UnorderedList.new(children: [
|
|
|
|
|
ListItem.new(children: [
|
|
|
|
|
Text.new(content: "List!"),
|
|
|
|
|
] of Child),
|
|
|
|
|
ListItem.new(children: [
|
|
|
|
|
Text.new(content: "Again!"),
|
|
|
|
|
] of Child),
|
2021-08-08 20:23:38 +02:00
|
|
|
] of Child),
|
2021-08-14 23:36:10 +02:00
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<p>Hello, <em>World!</em></p><ul><li>List!</li><li>Again!</li></ul>)
|
|
|
|
|
end
|
|
|
|
|
|
2021-07-04 23:06:17 +02:00
|
|
|
it "renders an anchor" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Anchor.new(children: [Text.new("link")] of Child, href: "https://example.com"),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
2021-07-04 23:06:17 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<a href="https://example.com">link</a>)
|
|
|
|
|
end
|
|
|
|
|
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
it "renders a blockquote" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
BlockQuote.new(children: [
|
|
|
|
|
Text.new("Wayne Gretzky. Michael Scott."),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<blockquote>Wayne Gretzky. Michael Scott.</blockquote>)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders code" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Code.new(children: [
|
|
|
|
|
Text.new("foo = bar"),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<code>foo = bar</code>)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders empasis" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Paragraph.new(children: [
|
|
|
|
|
Text.new(content: "This is "),
|
|
|
|
|
Emphasis.new(children: [
|
|
|
|
|
Text.new(content: "neat!"),
|
|
|
|
|
] of Child),
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
] of Child),
|
2021-08-14 23:36:10 +02:00
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<p>This is <em>neat!</em></p>)
|
|
|
|
|
end
|
|
|
|
|
|
2021-07-05 20:10:40 +02:00
|
|
|
it "renders a figure and figure caption" do
|
2021-08-15 21:08:03 +02:00
|
|
|
children = [Text.new("A caption")] of Child
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Figure.new(children: [
|
|
|
|
|
Image.new(src: "image.png", originalWidth: 100, originalHeight: 200),
|
2021-08-15 21:08:03 +02:00
|
|
|
FigureCaption.new(children: children),
|
2021-07-05 20:10:40 +02:00
|
|
|
] of Child),
|
2021-08-14 23:36:10 +02:00
|
|
|
] of Child
|
|
|
|
|
)
|
2021-07-05 20:10:40 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq stripped_html <<-HTML
|
|
|
|
|
<figure>
|
2021-08-14 22:07:31 +02:00
|
|
|
<img src="https://cdn-images-1.medium.com/fit/c/100/200/image.png" width="100">
|
2021-08-15 21:08:03 +02:00
|
|
|
<label class="margin-toggle" for="#{children.hash}">✍︎</label>
|
|
|
|
|
<input class="margin-toggle" type="checkbox" id="#{children.hash}">
|
|
|
|
|
<span class="marginnote">
|
|
|
|
|
A caption
|
|
|
|
|
</span>
|
2021-07-05 20:10:40 +02:00
|
|
|
</figure>
|
|
|
|
|
HTML
|
|
|
|
|
end
|
|
|
|
|
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
it "renders an H3" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Heading2.new(children: [
|
|
|
|
|
Text.new(content: "Title!"),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
2021-08-14 22:12:01 +02:00
|
|
|
html.should eq %(<h2>Title!</h2>)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders an H4" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Heading3.new(children: [
|
|
|
|
|
Text.new(content: "In Conclusion..."),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
2021-08-14 22:12:01 +02:00
|
|
|
html.should eq %(<h3>In Conclusion...</h3>)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders an image" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Paragraph.new(children: [
|
|
|
|
|
Image.new(src: "image.png", originalWidth: 100, originalHeight: 200),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
2021-07-05 20:54:58 +02:00
|
|
|
html.should eq stripped_html <<-HTML
|
|
|
|
|
<p>
|
2021-08-14 22:07:31 +02:00
|
|
|
<img src="https://cdn-images-1.medium.com/fit/c/100/200/image.png" width="100">
|
2021-07-05 20:54:58 +02:00
|
|
|
</p>
|
|
|
|
|
HTML
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders an iframe container" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Paragraph.new(children: [
|
|
|
|
|
IFrame.new(href: "https://example.com"),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
2021-07-05 21:36:38 +02:00
|
|
|
html.should eq stripped_html <<-HTML
|
|
|
|
|
<p>
|
|
|
|
|
<div class="embedded">
|
|
|
|
|
<a href="https://example.com">Embedded content at example.com</a>
|
|
|
|
|
</div>
|
|
|
|
|
</p>
|
|
|
|
|
HTML
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders an ordered list" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
OrderedList.new(children: [
|
|
|
|
|
ListItem.new(children: [Text.new("One")] of Child),
|
|
|
|
|
ListItem.new(children: [Text.new("Two")] of Child),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<ol><li>One</li><li>Two</li></ol>)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders an preformatted text" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Paragraph.new(children: [
|
|
|
|
|
Text.new("Hello, world!"),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<p>Hello, world!</p>)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders an preformatted text" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Preformatted.new(children: [
|
|
|
|
|
Text.new("New\nline"),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<pre>New\nline</pre>)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders strong text" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
Strong.new(children: [
|
|
|
|
|
Text.new("Oh yeah!"),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<strong>Oh yeah!</strong>)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
it "renders an unordered list" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
UnorderedList.new(children: [
|
|
|
|
|
ListItem.new(children: [Text.new("Apple")] of Child),
|
|
|
|
|
ListItem.new(children: [Text.new("Banana")] of Child),
|
|
|
|
|
] of Child),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<ul><li>Apple</li><li>Banana</li></ul>)
|
|
|
|
|
end
|
2021-07-04 23:37:45 +02:00
|
|
|
|
|
|
|
|
it "renders a user anchor" do
|
2021-08-14 23:36:10 +02:00
|
|
|
page = Page.new(
|
|
|
|
|
title: "Title",
|
|
|
|
|
subtitle: nil,
|
2021-09-04 23:15:30 +02:00
|
|
|
author: "Author",
|
2021-09-04 23:32:27 +02:00
|
|
|
created_at: Time.local,
|
2021-08-14 23:36:10 +02:00
|
|
|
nodes: [
|
|
|
|
|
UserAnchor.new(children: [Text.new("Some User")] of Child, userId: "abc123"),
|
|
|
|
|
] of Child
|
|
|
|
|
)
|
2021-07-04 23:37:45 +02:00
|
|
|
|
|
|
|
|
html = PageContent.new(page: page).render_to_string
|
|
|
|
|
|
|
|
|
|
html.should eq %(<a href="https://medium.com/u/abc123">Some User</a>)
|
|
|
|
|
end
|
First step rendering a page
The API responds with a bunch of paragraphs which the client converts
into Paragraph objects.
This turns the paragraphs in a PostResponse's Paragraph objects into the
form needed to render them on a page. This includes converting flat list
elements into list elements nested by a UL. And adding a limited markups
along the way.
The array of paragraphs is passed to a recursive function. The function
takes the first paragraph and either wraps the (marked up) contents in a
container tag (like Paragraph or Heading3), and then moves onto the next
tag. If it finds a list, it starts parsing the next paragraphs as a list
instead.
Originally, this was implemented like so:
```crystal
paragraph = paragraphs.shift
if list?
convert_list([paragraph] + paragraphs)
end
```
However, passing the `paragraphs` after adding it to the already shifted
`paragraph` creates a new object. This means `paragraphs` won't be
mutated and once the list is parsed, it starts with the next element of
the list. Instead, the element is `shift`ed inside each converter.
```crystal
if paragraphs.first == list?
convert_list(paragraphs)
end
def convert_list(paragraphs)
paragraph = paragraphs.shift
# ...
end
```
When rendering, there is an Empty and Container object. These represent
a kind of "null object" for both leafs and parent objects respectively.
They should never actually render. Emptys are filtered out, and
Containers are never created explicitly but this will make the types
pass.
IFrames are a bit of a special case. Each IFrame has custom data on it
that this system would need to be aware of. For now, instead of trying
to parse the seemingly large number of iframe variations and dealing
with embedded iframe problems, this will just keep track of the source
page URL and send the user there with a link.
2021-05-16 20:14:25 +02:00
|
|
|
end
|
2021-07-05 20:10:40 +02:00
|
|
|
|
|
|
|
|
def stripped_html(html : String)
|
|
|
|
|
html.gsub(/\n\s*/, "").strip
|
|
|
|
|
end
|