getPath() {
75 | return path;
76 | }
77 |
78 | /**
79 | * @return the first rich list of the path.
80 | */
81 | @Nullable public CDARichList getTopListOfPath() {
82 | for (int i = path.size() - 2; i >= 0; --i) {
83 | final CDARichNode node = path.get(i);
84 | if (node instanceof CDARichList) {
85 | return (CDARichList) node;
86 | }
87 | }
88 | return null;
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/AndroidProcessor.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android;
2 |
3 | import android.view.View;
4 |
5 | import com.contentful.rich.android.renderer.chars.CharSequenceRendererProvider;
6 | import com.contentful.rich.android.renderer.views.NativeViewsRendererProvider;
7 | import com.contentful.rich.core.Processor;
8 |
9 | import javax.annotation.Nonnull;
10 |
11 | /**
12 | * Processor processing rich text to create Android output.
13 | *
14 | * Use one of the factory methods to create an Android processor creating your desired output.
15 | *
16 | * @see AndroidProcessor#creatingCharSequences()
17 | */
18 | public class AndroidProcessor extends Processor {
19 |
20 | /**
21 | * Hide constructor to force creation through factory methods.
22 | */
23 | private AndroidProcessor() {
24 | }
25 |
26 | /**
27 | * Create an Android Processor capable of generating char sequences from rich text input nodes.
28 | *
29 | * @return AndroidProcessor to create char sequences
30 | * @see android.text.Spannable
31 | */
32 | public static AndroidProcessor creatingCharSequences() {
33 | final AndroidProcessor processor = new AndroidProcessor<>();
34 | new CharSequenceRendererProvider().provide(processor);
35 |
36 | return processor;
37 | }
38 |
39 | public static AndroidProcessor creatingNativeViews() {
40 | final AndroidProcessor processor = new AndroidProcessor<>();
41 | new NativeViewsRendererProvider().provide(processor);
42 |
43 | return processor;
44 | }
45 |
46 | /**
47 | * Add a renderer to the processor using only one class.
48 | *
49 | * @param renderer the combined Android renderer
50 | * @return this instance for chaining
51 | * @see com.contentful.rich.core.RenderabilityChecker
52 | * @see com.contentful.rich.core.Renderer
53 | */
54 | @Nonnull
55 | public Processor addRenderer(@Nonnull AndroidRenderer renderer) {
56 | return super.addRenderer(renderer, renderer);
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/AndroidRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android;
2 |
3 | import com.contentful.java.cda.rich.CDARichNode;
4 | import com.contentful.rich.core.RenderabilityChecker;
5 | import com.contentful.rich.core.Context;
6 | import com.contentful.rich.core.Renderer;
7 |
8 | import javax.annotation.Nonnull;
9 | import javax.annotation.Nullable;
10 |
11 | /**
12 | * This is a combination interface for android renderer
13 | *
14 | * @param context to be applied to this renderer.
15 | * @param result of rendering a node.
16 | */
17 | public abstract class AndroidRenderer implements RenderabilityChecker, Renderer {
18 | protected final AndroidProcessor processor;
19 |
20 | /**
21 | * Create an Android Renderer, containing its processor for child node rendering.
22 | *
23 | * @param processor save the processor for child processing.
24 | */
25 | public AndroidRenderer(@Nonnull AndroidProcessor processor) {
26 | this.processor = processor;
27 | }
28 |
29 | /**
30 | * Overwritten to check on whether this renderer can be used to render this node in the given context.
31 | *
32 | * @param context context this check should be performed in
33 | * @param node node to be checked
34 | * @return true if the node can be rendered in the context.
35 | */
36 | @Override abstract public boolean canRender(@Nullable C context, @Nonnull CDARichNode node);
37 |
38 | /**
39 | * Performs the rendering resulting in type R.
40 | *
41 | * @param context the generic context this node should be rendered in.
42 | * @param node the node to be rendered.
43 | * @return the rendered result.
44 | */
45 | @Nullable @Override abstract public R render(@Nonnull C context, @Nonnull CDARichNode node);
46 | }
47 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/chars/BlockRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.chars;
2 |
3 | import android.text.SpannableStringBuilder;
4 | import android.text.style.LeadingMarginSpan;
5 |
6 | import com.contentful.java.cda.rich.CDARichBlock;
7 | import com.contentful.java.cda.rich.CDARichList;
8 | import com.contentful.java.cda.rich.CDARichNode;
9 | import com.contentful.rich.android.AndroidContext;
10 | import com.contentful.rich.android.AndroidProcessor;
11 | import com.contentful.rich.android.AndroidRenderer;
12 |
13 | import java.util.List;
14 |
15 | import javax.annotation.Nonnull;
16 | import javax.annotation.Nullable;
17 |
18 | import androidx.annotation.NonNull;
19 |
20 | import static android.text.Spanned.SPAN_EXCLUSIVE_EXCLUSIVE;
21 |
22 | /**
23 | * Renders the given block and all of it's child nodes.
24 | */
25 | public class BlockRenderer extends AndroidRenderer {
26 | /**
27 | * Create a new BlockRenderer.
28 | *
29 | * @param processor to be used for child processing.
30 | */
31 | public BlockRenderer(@Nonnull AndroidProcessor processor) {
32 | super(processor);
33 | }
34 |
35 | /**
36 | * Can the given node be rendered with this renderer and the given context?
37 | *
38 | * @param context context this check should be performed in
39 | * @param node node to be checked
40 | * @return true if the node can be rendered.
41 | */
42 | @Override public boolean canRender(@Nullable AndroidContext context, @Nonnull CDARichNode node) {
43 | if (context != null) {
44 | if (node instanceof CDARichBlock) {
45 | return true;
46 | }
47 | }
48 |
49 | return false;
50 | }
51 |
52 | /**
53 | * Perform rendering of the given block into the a character sequence.
54 | *
55 | * @param context the generic context this node should be rendered in.
56 | * @param node the node to be rendered.
57 | * @return all child nodes and this block rendered into one character sequence.
58 | */
59 | @Nullable @Override public CharSequence render(@Nonnull AndroidContext context, @Nonnull CDARichNode node) {
60 | final CDARichBlock block = (CDARichBlock) node;
61 |
62 | final SpannableStringBuilder result = new SpannableStringBuilder();
63 |
64 | if (block.getContent() != null) {
65 | for (final CDARichNode childNode : block.getContent()) {
66 | if (childNode != null) {
67 | final CharSequence childResult = processor.process(context, childNode);
68 | if (childResult != null) {
69 | result.append(childResult);
70 | }
71 | }
72 | }
73 | }
74 | childWithNewline(result);
75 |
76 | return wrap(node, indent(context, node, decorate(context, node, result)));
77 | }
78 |
79 | /**
80 | * Ensures child ends on exactly one newline.
81 | *
82 | * @param builder the current rendered spannable builder.
83 | */
84 | @Nonnull
85 | protected void childWithNewline(@Nonnull SpannableStringBuilder builder) {
86 | if (builder != null) {
87 | String text = builder.toString();
88 | if (text != null) {
89 | while (text.endsWith("\n")) {
90 | text = text.substring(0, text.length() - 1);
91 | }
92 | builder.clear();
93 | builder.append(text);
94 | }
95 | }
96 | }
97 |
98 | /**
99 | * Prefix given builder by a custom decoration.
100 | *
101 | * @param context the context this decoration should be applied to.
102 | * @param node the actual node, rendered into the builder.
103 | * @param builder a builder for generating the desired output.
104 | * @return builder for convenience.
105 | */
106 | @Nonnull
107 | protected SpannableStringBuilder decorate(@Nonnull AndroidContext context, @Nonnull CDARichNode node, @Nonnull SpannableStringBuilder builder) {
108 | return builder;
109 | }
110 |
111 | /**
112 | * Surround the given builder, if needed
113 | *
114 | * @param node the node to be rendered.
115 | * @param builder the result of the rendering.
116 | * @return the rendered result plus a optional wrap.
117 | */
118 | @NonNull
119 | public SpannableStringBuilder wrap(@Nonnull CDARichNode node, @Nonnull SpannableStringBuilder builder) {
120 | return builder;
121 | }
122 |
123 | /**
124 | * Add inline spannables to the first character to ensure indentation as needed.
125 | *
126 | * @param context of the node to be indented.
127 | * @param node the node to be indented.
128 | * @param builder the result of the node's children to be indented.
129 | * @return an indented spannable.
130 | */
131 | @Nonnull SpannableStringBuilder indent(
132 | @Nonnull AndroidContext context,
133 | @Nonnull CDARichNode node,
134 | @Nonnull SpannableStringBuilder builder) {
135 | int lists = 0;
136 | final List path = context.getPath();
137 | if (path != null) {
138 | for (final CDARichNode pathElement : path) {
139 | if (pathElement instanceof CDARichList) {
140 | lists++;
141 | }
142 | }
143 | }
144 |
145 | if (lists > 1) {
146 | final CDARichBlock block = (CDARichBlock) node;
147 | if (block.getContent().size() > 0) {
148 | if (block.getContent().get(0) instanceof CDARichBlock) {
149 | builder.append("\n");
150 | }
151 | }
152 | builder.setSpan(new LeadingMarginSpan.Standard(lists * 10 /*px*/), 0, builder.length(), SPAN_EXCLUSIVE_EXCLUSIVE);
153 | }
154 |
155 | return builder;
156 | }
157 | }
158 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/chars/CharSequenceRendererProvider.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.chars;
2 |
3 | import com.contentful.rich.android.AndroidProcessor;
4 | import com.contentful.rich.android.renderer.listdecorator.BulletDecorator;
5 | import com.contentful.rich.android.renderer.listdecorator.LowerCaseCharacterDecorator;
6 | import com.contentful.rich.android.renderer.listdecorator.LowerCaseRomanNumeralsDecorator;
7 | import com.contentful.rich.android.renderer.listdecorator.NumbersDecorator;
8 | import com.contentful.rich.android.renderer.listdecorator.UpperCaseCharacterDecorator;
9 | import com.contentful.rich.android.renderer.listdecorator.UpperCaseRomanNumeralsDecorator;
10 |
11 | import javax.annotation.Nonnull;
12 |
13 | /**
14 | * This provider will be used to fill the processor with renderer used in the text rendering for android.
15 | */
16 | public class CharSequenceRendererProvider {
17 |
18 | /**
19 | * Add all relevant renderers to the AndroidProcessor.
20 | *
21 | * @param processor to be modified.
22 | */
23 | public void provide(@Nonnull AndroidProcessor processor) {
24 | processor.addRenderer(new HorizontalRuleRenderer(processor));
25 | processor.addRenderer(new TextRenderer(processor));
26 | processor.addRenderer(new HeadingRenderer(processor));
27 | processor.addRenderer(new ListRenderer(processor, new BulletDecorator()));
28 | processor.addRenderer(new ListRenderer(processor,
29 | new NumbersDecorator(),
30 | new UpperCaseCharacterDecorator(),
31 | new LowerCaseRomanNumeralsDecorator(),
32 | new LowerCaseCharacterDecorator(),
33 | new LowerCaseCharacterDecorator(),
34 | new UpperCaseRomanNumeralsDecorator()
35 | ));
36 | processor.addRenderer(new HyperLinkRenderer(processor));
37 | processor.addRenderer(new QuoteRenderer(processor));
38 | processor.addRenderer(new BlockRenderer(processor));
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/chars/HeadingRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.chars;
2 |
3 | import android.text.SpannableStringBuilder;
4 | import android.text.Spanned;
5 | import android.text.style.AbsoluteSizeSpan;
6 | import com.contentful.java.cda.rich.CDARichHeading;
7 | import com.contentful.java.cda.rich.CDARichNode;
8 | import com.contentful.rich.android.AndroidContext;
9 | import com.contentful.rich.android.AndroidProcessor;
10 |
11 | import javax.annotation.Nonnull;
12 | import javax.annotation.Nullable;
13 | import java.util.ArrayList;
14 | import java.util.List;
15 |
16 | /**
17 | * Render all available headings into a spannable changing it's vertical size.
18 | */
19 | public class HeadingRenderer extends BlockRenderer {
20 |
21 | static private final List SIZE_MAP = new ArrayList<>();
22 |
23 | static {
24 | SIZE_MAP.add(72); // Level 1
25 | SIZE_MAP.add(60); // Level 2
26 | SIZE_MAP.add(52); // Level 3
27 | SIZE_MAP.add(44); // Level 4
28 | SIZE_MAP.add(36); // Level 5
29 | SIZE_MAP.add(28); // Level 6
30 | }
31 |
32 | public HeadingRenderer(@Nonnull AndroidProcessor processor) {
33 | super(processor);
34 | }
35 |
36 | /**
37 | * Is the given node a CDARichHeading?
38 | *
39 | * @param context context this check should be performed in
40 | * @param node node to be checked
41 | * @return true if node is a rich CDARichHeading.
42 | */
43 | @Override public boolean canRender(@Nullable AndroidContext context, @Nonnull CDARichNode node) {
44 | if (node instanceof CDARichHeading) {
45 | final CDARichHeading heading = (CDARichHeading) node;
46 | if (heading.getLevel() > 0 && ((CDARichHeading) node).getLevel() < 7) {
47 | return true;
48 | }
49 | }
50 |
51 | return false;
52 | }
53 |
54 | /**
55 | * Add a size changing span to the rendered children.
56 | *
57 | * @param node the node to be rendered.
58 | * @param builder the result of the rendering.
59 | * @return the builder, enhanced by a size altering span.
60 | */
61 | @Nonnull @Override
62 | public SpannableStringBuilder wrap(@Nonnull CDARichNode node, @Nonnull SpannableStringBuilder builder) {
63 | final CDARichHeading heading = (CDARichHeading) node;
64 |
65 | final AbsoluteSizeSpan sizeSpan = new AbsoluteSizeSpan(SIZE_MAP.get(heading.getLevel() - 1), true);
66 | builder.setSpan(sizeSpan, 0, builder.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
67 |
68 | return builder;
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/chars/HorizontalRuleRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.chars;
2 |
3 | import android.text.Spannable;
4 | import android.text.SpannableStringBuilder;
5 | import android.text.style.StrikethroughSpan;
6 |
7 | import com.contentful.java.cda.rich.CDARichHorizontalRule;
8 | import com.contentful.java.cda.rich.CDARichNode;
9 | import com.contentful.rich.android.AndroidContext;
10 | import com.contentful.rich.android.AndroidProcessor;
11 | import com.contentful.rich.android.AndroidRenderer;
12 |
13 | import javax.annotation.Nonnull;
14 | import javax.annotation.Nullable;
15 |
16 | import static android.text.Spanned.SPAN_EXCLUSIVE_EXCLUSIVE;
17 |
18 | /**
19 | * Renderer for a horizontal rule.
20 | */
21 | public class HorizontalRuleRenderer extends AndroidRenderer {
22 | /**
23 | * Create the renderer, referencing its processor.
24 | *
25 | * This element does not have any children.
26 | *
27 | * @param processor the unused processor for this renderer.
28 | */
29 | public HorizontalRuleRenderer(@Nonnull AndroidProcessor processor) {
30 | super(processor);
31 | }
32 |
33 | /**
34 | * Check if the given node is a horizontal rule.
35 | *
36 | * @param context context this check should be performed in
37 | * @param node node to be checked
38 | * @return true if the given node is a rule
39 | */
40 | @Override public boolean canRender(@Nullable AndroidContext context, @Nonnull CDARichNode node) {
41 | return node instanceof CDARichHorizontalRule;
42 | }
43 |
44 | /**
45 | * Render a horizontal line.
46 | *
47 | * @param context the generic context this node should be rendered in.
48 | * @param node the node to be rendered.
49 | * @return a span containing only a line.
50 | */
51 | @Nullable @Override
52 | public CharSequence render(@Nonnull AndroidContext context, @Nonnull CDARichNode node) {
53 | final Spannable result = new SpannableStringBuilder(" ");
54 | result.setSpan(new StrikethroughSpan(), 0, result.length(), SPAN_EXCLUSIVE_EXCLUSIVE);
55 | return result;
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/chars/HyperLinkRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.chars;
2 |
3 | import android.text.SpannableStringBuilder;
4 | import android.text.Spanned;
5 | import android.text.method.MovementMethod;
6 | import android.text.style.URLSpan;
7 | import androidx.annotation.NonNull;
8 | import com.contentful.java.cda.rich.CDARichHyperLink;
9 | import com.contentful.java.cda.rich.CDARichNode;
10 | import com.contentful.rich.android.AndroidContext;
11 | import com.contentful.rich.android.AndroidProcessor;
12 |
13 | import javax.annotation.Nonnull;
14 | import javax.annotation.Nullable;
15 | import java.util.Map;
16 |
17 | /**
18 | * Render the children into a hyperlink.
19 | *
20 | * Please remember to use {@link android.widget.TextView#setMovementMethod(MovementMethod)}
21 | * with {@link android.text.method.LinkMovementMethod#}
22 | */
23 | public class HyperLinkRenderer extends BlockRenderer {
24 |
25 | /**
26 | * Create the processor preserving hyperlink renderer.
27 | *
28 | * @param processor the processor to be used for child rendering.
29 | */
30 | public HyperLinkRenderer(@Nonnull AndroidProcessor processor) {
31 | super(processor);
32 | }
33 |
34 | /**
35 | * Checks if the giben node is a hyperlink.
36 | *
37 | * @param context context this check should be performed in
38 | * @param node node to be checked
39 | * @return true if the given node is a hyperlink.
40 | */
41 | @Override public boolean canRender(@Nullable AndroidContext context, @Nonnull CDARichNode node) {
42 | if (!(node instanceof CDARichHyperLink)) {
43 | return false;
44 | }
45 | Object data = ((CDARichHyperLink)node).getData();
46 | return data instanceof String || (data instanceof Map && ((Map) data).containsKey("uri"));
47 | }
48 |
49 | /**
50 | * Decorate the rendered children to either be using a clickable span.
51 | *
52 | * @param context the context this decoration should be applied to.
53 | * @param node the actual node, rendered into the builder.
54 | * @param builder a builder for generating the desired output.
55 | * @return the enhanced children, rendered as a hyperlink.
56 | */
57 | @NonNull @Override protected SpannableStringBuilder decorate(
58 | @Nonnull AndroidContext context,
59 | @Nonnull CDARichNode node,
60 | @Nonnull SpannableStringBuilder builder) {
61 |
62 | final CDARichHyperLink link = (CDARichHyperLink) node;
63 | final Object data = link.getData();
64 | final String uri;
65 |
66 | if (data instanceof String) {
67 | uri = (String) data;
68 | } else if (data instanceof Map) {
69 | uri = (String) ((Map) data).get("uri");
70 | } else {
71 | return builder; // Return unchanged if data is neither String nor Map
72 | }
73 |
74 | final URLSpan span = new URLSpan(uri);
75 | builder.setSpan(span, 0, builder.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
76 | return builder;
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/chars/QuoteRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.chars;
2 |
3 | import android.text.SpannableStringBuilder;
4 | import android.text.Spanned;
5 |
6 | import com.contentful.java.cda.rich.CDARichNode;
7 | import com.contentful.java.cda.rich.CDARichQuote;
8 | import com.contentful.rich.android.AndroidContext;
9 | import com.contentful.rich.android.AndroidProcessor;
10 | import com.contentful.rich.android.renderer.chars.span.QuoteSpan;
11 |
12 | import javax.annotation.Nonnull;
13 | import javax.annotation.Nullable;
14 |
15 | import androidx.annotation.NonNull;
16 |
17 | /**
18 | * Add a fancy bar next to the children, to indicate this text is a quote.
19 | */
20 | public class QuoteRenderer extends BlockRenderer {
21 |
22 | /**
23 | * Create a new quote renderer, saving its processor for child node processing.
24 | *
25 | * @param processor
26 | */
27 | public QuoteRenderer(@Nonnull AndroidProcessor processor) {
28 | super(processor);
29 | }
30 |
31 | /**
32 | * Is the given node a quote?
33 | *
34 | * @param context context this check should be performed in
35 | * @param node node to be checked
36 | * @return true or false. Depending on whether the node given is a CDARichQuote.
37 | */
38 | @Override public boolean canRender(@Nullable AndroidContext context, @Nonnull CDARichNode node) {
39 | return node instanceof CDARichQuote;
40 | }
41 |
42 | /**
43 | * Decorate the given children by adding a start-aligned bar.
44 | *
45 | * @param context the context this decoration should be applied to.
46 | * @param node the actual node, rendered into the builder.
47 | * @param renderedChildren the rendered child nodes as a builder.
48 | * @return the builder, enhanced by vertical bar.
49 | */
50 | @NonNull @Override protected SpannableStringBuilder decorate(
51 | @Nonnull AndroidContext context,
52 | @Nonnull CDARichNode node,
53 | @Nonnull SpannableStringBuilder renderedChildren) {
54 |
55 | final QuoteSpan span = new QuoteSpan(0x80808080, 30, 20);
56 | renderedChildren.setSpan(span, 0, renderedChildren.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
57 | return renderedChildren;
58 | }
59 |
60 | }
61 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/chars/TextRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.chars;
2 |
3 | import android.graphics.Typeface;
4 | import android.text.Spannable;
5 | import android.text.SpannableStringBuilder;
6 | import android.text.style.BackgroundColorSpan;
7 | import android.text.style.StyleSpan;
8 | import android.text.style.SubscriptSpan;
9 | import android.text.style.SuperscriptSpan;
10 | import android.text.style.TextAppearanceSpan;
11 | import android.text.style.UnderlineSpan;
12 | import com.contentful.java.cda.rich.CDARichMark;
13 | import com.contentful.java.cda.rich.CDARichMark.CDARichMarkBold;
14 | import com.contentful.java.cda.rich.CDARichMark.CDARichMarkItalic;
15 | import com.contentful.java.cda.rich.CDARichNode;
16 | import com.contentful.java.cda.rich.CDARichText;
17 | import com.contentful.rich.android.AndroidContext;
18 | import com.contentful.rich.android.AndroidProcessor;
19 | import com.contentful.rich.android.AndroidRenderer;
20 |
21 | import javax.annotation.Nonnull;
22 | import javax.annotation.Nullable;
23 |
24 | import static android.text.Spanned.SPAN_EXCLUSIVE_EXCLUSIVE;
25 | import static com.contentful.java.cda.rich.CDARichMark.CDARichMarkCode;
26 | import static com.contentful.java.cda.rich.CDARichMark.CDARichMarkCustom;
27 | import static com.contentful.java.cda.rich.CDARichMark.CDARichMarkUnderline;
28 |
29 | /**
30 | * This renderer will render a rich text node into a spannable, respecting it's marks.
31 | */
32 | public class TextRenderer extends AndroidRenderer {
33 | /**
34 | * Constructor taking a processor for child processing.
35 | *
36 | * Since CDARichText do not have children, the parameter will be ignored.
37 | *
38 | * @param processor used for subrendering of children.
39 | */
40 | public TextRenderer(@Nonnull AndroidProcessor processor) {
41 | super(processor);
42 | }
43 |
44 | /**
45 | * Is the incoming node a rich text?
46 | *
47 | * @param context context this check should be performed in
48 | * @param node node to be checked
49 | * @return true if the node is a rich text node.
50 | */
51 | @Override public boolean canRender(@Nullable AndroidContext context, @Nonnull CDARichNode node) {
52 | return node instanceof CDARichText;
53 | }
54 |
55 | /**
56 | * Converts the incoming rich text into a string and adds spans according to its markers.
57 | *
58 | * @param context the generic context this node should be rendered in.
59 | * @param node the node to be rendered.
60 | * @return a spannable containing the text content of the rich text and decorations based on its markers.
61 | */
62 | @Nullable @Override public CharSequence render(@Nonnull AndroidContext context, @Nonnull CDARichNode node) {
63 | final CDARichText richText = (CDARichText) node;
64 |
65 | final Spannable result = new SpannableStringBuilder(richText.getText());
66 |
67 | for (final CDARichMark mark : richText.getMarks()) {
68 | if (mark instanceof CDARichMarkUnderline) {
69 | result.setSpan(new UnderlineSpan(), 0, result.length(), SPAN_EXCLUSIVE_EXCLUSIVE);
70 | }
71 | if (mark instanceof CDARichMarkBold) {
72 | result.setSpan(new StyleSpan(Typeface.BOLD), 0, result.length(), SPAN_EXCLUSIVE_EXCLUSIVE);
73 | }
74 | if (mark instanceof CDARichMark.CDARichMarkSubscript) {
75 | result.setSpan(new SubscriptSpan(), 0, result.length(), SPAN_EXCLUSIVE_EXCLUSIVE);
76 | }
77 | if (mark instanceof CDARichMark.CDARichMarkSuperscript) {
78 | result.setSpan(new SuperscriptSpan(), 0, result.length(), SPAN_EXCLUSIVE_EXCLUSIVE);
79 | }
80 | if (mark instanceof CDARichMarkItalic) {
81 | result.setSpan(new StyleSpan(Typeface.ITALIC), 0, result.length(), SPAN_EXCLUSIVE_EXCLUSIVE);
82 | }
83 | if (mark instanceof CDARichMarkCode) {
84 | result.setSpan(new TextAppearanceSpan("monospace", 0, 0, null, null), 0, result.length(), SPAN_EXCLUSIVE_EXCLUSIVE);
85 | }
86 | if (mark instanceof CDARichMarkCustom) {
87 | result.setSpan(new BackgroundColorSpan(0x80ffff00), 0, result.length(), SPAN_EXCLUSIVE_EXCLUSIVE);
88 | }
89 | }
90 |
91 | return result;
92 | }
93 | }
94 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/chars/span/QuoteSpan.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.chars.span;
2 |
3 | import android.graphics.Canvas;
4 | import android.graphics.Paint;
5 | import android.os.Parcel;
6 | import android.text.Layout;
7 | import android.text.ParcelableSpan;
8 | import android.text.style.LeadingMarginSpan;
9 |
10 | import androidx.annotation.ColorInt;
11 | import androidx.annotation.IntRange;
12 | import androidx.annotation.NonNull;
13 | import androidx.annotation.Px;
14 |
15 | /**
16 | * This is a custom span to decorate the children with a margin.
17 | */
18 | public class QuoteSpan implements LeadingMarginSpan, ParcelableSpan {
19 | @ColorInt
20 | private final int mColor;
21 | @Px
22 | private final int mStripeWidth;
23 | @Px
24 | private final int mGapWidth;
25 |
26 | /**
27 | * Creates a {@link android.text.style.QuoteSpan} based on a color, a stripe width and the width of the gap
28 | * between the stripe and the text.
29 | *
30 | * @param color the color of the quote stripe.
31 | * @param stripeWidth the width of the stripe.
32 | * @param gapWidth the width of the gap between the stripe and the text.
33 | */
34 | public QuoteSpan(@ColorInt int color, @IntRange(from = 0) int stripeWidth,
35 | @IntRange(from = 0) int gapWidth) {
36 | mColor = color;
37 | mStripeWidth = stripeWidth;
38 | mGapWidth = gapWidth;
39 | }
40 |
41 |
42 | @Override
43 | public int describeContents() {
44 | return 0;
45 | }
46 |
47 | @Override
48 | public void writeToParcel(Parcel dest, int flags) {
49 | writeToParcelInternal(dest, flags);
50 | }
51 |
52 | public void writeToParcelInternal(Parcel dest, int flags) {
53 | dest.writeInt(mColor);
54 | dest.writeInt(mStripeWidth);
55 | dest.writeInt(mGapWidth);
56 | }
57 |
58 | @Override
59 | public int getLeadingMargin(boolean first) {
60 | return mStripeWidth + mGapWidth;
61 | }
62 |
63 | @Override
64 | public void drawLeadingMargin(@NonNull Canvas c, @NonNull Paint p, int x, int dir,
65 | int top, int baseline, int bottom,
66 | @NonNull CharSequence text, int start, int end,
67 | boolean first, @NonNull Layout layout) {
68 | Paint.Style style = p.getStyle();
69 | int color = p.getColor();
70 |
71 | p.setStyle(Paint.Style.FILL);
72 | p.setColor(mColor);
73 |
74 | c.drawRect(x, top, x + dir * mStripeWidth, bottom, p);
75 |
76 | p.setStyle(style);
77 | p.setColor(color);
78 | }
79 |
80 | @Override public int getSpanTypeId() {
81 | return 1000;
82 | }
83 |
84 | public int getSpanTypeIdInternal() {
85 | return getSpanTypeId();
86 | }
87 |
88 | }
89 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/listdecorator/BulletDecorator.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.listdecorator;
2 |
3 | import android.text.SpannableString;
4 | import android.text.Spanned;
5 |
6 | import javax.annotation.Nonnull;
7 |
8 | public class BulletDecorator extends Decorator{
9 | @Nonnull @Override public CharSequence getSymbol() {
10 | return "*";
11 | }
12 |
13 | public @Nonnull CharSequence decorate(int position) {
14 | final SpannableString spannable = new SpannableString("• ");
15 | spannable.setSpan(this, 0, spannable.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
16 | return spannable;
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/listdecorator/Decorator.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.listdecorator;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class Decorator {
6 | @Nonnull public CharSequence getSymbol() {
7 | return "";
8 | }
9 |
10 | @Nonnull public CharSequence decorate(int position) {
11 | return "";
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/listdecorator/LowerCaseCharacterDecorator.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.listdecorator;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class LowerCaseCharacterDecorator extends UpperCaseCharacterDecorator {
6 | @Nonnull @Override public CharSequence getSymbol() {
7 | return "a";
8 | }
9 |
10 | public @Nonnull CharSequence decorate(int position) {
11 | return super.decorate(position).toString().toLowerCase();
12 | }
13 |
14 | }
15 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/listdecorator/LowerCaseRomanNumeralsDecorator.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.listdecorator;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class LowerCaseRomanNumeralsDecorator extends UpperCaseRomanNumeralsDecorator {
6 | @Nonnull @Override public CharSequence getSymbol() {
7 | return "i";
8 | }
9 |
10 | @Nonnull @Override
11 | public CharSequence decorate(int position) {
12 | return super.decorate(position).toString().toLowerCase();
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/listdecorator/NumbersDecorator.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.listdecorator;
2 |
3 | import android.text.SpannableString;
4 | import android.text.Spanned;
5 |
6 | import javax.annotation.Nonnull;
7 |
8 | public class NumbersDecorator extends Decorator {
9 | @Nonnull @Override public CharSequence getSymbol() {
10 | return "1";
11 | }
12 |
13 | public @Nonnull CharSequence decorate(int position) {
14 | final SpannableString spannable = new SpannableString(position + ". ");
15 | spannable.setSpan(this, 0, spannable.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
16 | return spannable;
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/listdecorator/UpperCaseCharacterDecorator.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.listdecorator;
2 |
3 | import android.text.SpannableString;
4 | import android.text.Spanned;
5 |
6 | import javax.annotation.Nonnull;
7 |
8 | public class UpperCaseCharacterDecorator extends Decorator {
9 | @Nonnull @Override public CharSequence getSymbol() {
10 | return "A";
11 | }
12 |
13 | public @Nonnull CharSequence decorate(int position) {
14 | final SpannableString spannable = new SpannableString(getColumnDecoration(position - 1) + ". ");
15 | spannable.setSpan(this, 0, spannable.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
16 | return spannable;
17 | }
18 |
19 | private CharSequence getColumnDecoration(int index) {
20 | if (index < 26) {
21 | return Character.toString((char) ('A' + index));
22 | } else {
23 | return getColumnDecoration((index / 26) - 1).toString() + getColumnDecoration(index % 26);
24 | }
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/listdecorator/UpperCaseRomanNumeralsDecorator.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.listdecorator;
2 |
3 | import android.text.SpannableString;
4 | import android.text.Spanned;
5 |
6 | import java.util.TreeMap;
7 |
8 | import javax.annotation.Nonnull;
9 |
10 | public class UpperCaseRomanNumeralsDecorator extends Decorator {
11 | private final TreeMap map = new TreeMap<>();
12 |
13 | public UpperCaseRomanNumeralsDecorator() {
14 | map.put(1000, "M");
15 | map.put(900, "CM");
16 | map.put(500, "D");
17 | map.put(400, "CD");
18 | map.put(100, "C");
19 | map.put(90, "XC");
20 | map.put(50, "L");
21 | map.put(40, "XL");
22 | map.put(10, "X");
23 | map.put(9, "IX");
24 | map.put(5, "V");
25 | map.put(4, "IV");
26 | map.put(3, "III");
27 | map.put(2, "II");
28 | map.put(1, "I");
29 | }
30 |
31 | @Nonnull @Override public CharSequence getSymbol() {
32 | return "I";
33 | }
34 |
35 | @Nonnull @Override
36 | public CharSequence decorate(int position) {
37 | final SpannableString spannable = new SpannableString(getRomanDecoration(position) + ". ");
38 | spannable.setSpan(this, 0, spannable.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
39 | return spannable;
40 | }
41 |
42 | public CharSequence getRomanDecoration(int index) {
43 | try {
44 | int l = map.floorKey(index);
45 | if (index == l) {
46 | return map.get(index);
47 | }
48 | return map.get(l) + getRomanDecoration(index - l);
49 | } catch (NullPointerException e) {
50 | return " ";
51 | }
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/views/BlockRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.views;
2 |
3 | import android.text.SpannableStringBuilder;
4 | import android.view.View;
5 | import android.view.ViewGroup;
6 | import android.widget.TextView;
7 | import android.widget.LinearLayout;
8 |
9 | import com.contentful.java.cda.rich.CDARichBlock;
10 | import com.contentful.java.cda.rich.CDARichNode;
11 | import com.contentful.rich.android.AndroidContext;
12 | import com.contentful.rich.android.AndroidProcessor;
13 | import com.contentful.rich.android.AndroidRenderer;
14 | import com.contentful.rich.android.R;
15 |
16 | import javax.annotation.Nonnull;
17 | import javax.annotation.Nullable;
18 |
19 | public class BlockRenderer extends AndroidRenderer {
20 | public BlockRenderer(@Nonnull AndroidProcessor processor) {
21 | super(processor);
22 | }
23 |
24 | @Override public boolean canRender(@Nullable AndroidContext context, @Nonnull CDARichNode node) {
25 | return node instanceof CDARichBlock;
26 | }
27 |
28 | @Nullable @Override public View render(@Nonnull AndroidContext context, @Nonnull CDARichNode node) {
29 | final CDARichBlock block = (CDARichBlock) node;
30 | final View result = inflateRichLayout(context, node);
31 | final ViewGroup content = result.findViewById(R.id.rich_content);
32 |
33 | TextView lastTextView = null;
34 | for (final CDARichNode childNode : block.getContent()) {
35 | final View childView = processor.process(context, childNode);
36 |
37 | if (childView != null) {
38 | if (childView instanceof TextView) {
39 | final TextView childTextView = (TextView) childView;
40 | if (lastTextView != null) {
41 | CharSequence lastText = lastTextView.getText();
42 | CharSequence childText = childTextView.getText();
43 | if (lastText == null) {
44 | lastText = "";
45 | }
46 | if (childText == null) {
47 | childText = "";
48 | }
49 | lastTextView.setText(new SpannableStringBuilder(lastText).append(childText));
50 | if(childTextView.getMovementMethod() != null) {
51 | lastTextView.setMovementMethod(childTextView.getMovementMethod());
52 | }
53 | } else {
54 | lastTextView = childTextView;
55 | content.addView(childView);
56 | }
57 | } else {
58 | if (context.getPath() != null && context.getPath().size() > 1) {
59 | final View indented = context.getInflater().inflate(R.layout.rich_indention_layout, null, false);
60 | ((ViewGroup) indented.findViewById(R.id.rich_content)).addView(childView);
61 | content.addView(indented);
62 | } else {
63 | // Add margin to the child view
64 | LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
65 | LinearLayout.LayoutParams.MATCH_PARENT,
66 | LinearLayout.LayoutParams.WRAP_CONTENT
67 | );
68 | params.topMargin = 16; // Add 16dp margin at the top
69 | childView.setLayoutParams(params);
70 | content.addView(childView);
71 | }
72 | }
73 | }
74 | }
75 |
76 | return result;
77 | }
78 |
79 | protected View inflateRichLayout(@Nonnull AndroidContext context, @Nonnull CDARichNode node) {
80 | return context.getInflater().inflate(R.layout.rich_block_layout, null, false);
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/views/EmbeddedLinkRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.views;
2 |
3 | import android.view.View;
4 | import android.view.ViewGroup;
5 | import android.widget.ImageView;
6 | import android.widget.TextView;
7 |
8 | import com.contentful.java.cda.CDAAsset;
9 | import com.contentful.java.cda.CDAEntry;
10 | import com.contentful.java.cda.rich.CDARichEmbeddedInline;
11 | import com.contentful.java.cda.rich.CDARichNode;
12 | import com.contentful.rich.android.AndroidContext;
13 | import com.contentful.rich.android.AndroidProcessor;
14 | import com.contentful.rich.android.R;
15 | import com.contentful.rich.android.renderer.chars.EmbeddedLinkRenderer.BitmapProvider;
16 |
17 | import javax.annotation.Nonnull;
18 | import javax.annotation.Nullable;
19 |
20 | import static com.contentful.rich.android.renderer.chars.EmbeddedLinkRenderer.defaultBitmapProvider;
21 |
22 | public class EmbeddedLinkRenderer extends BlockRenderer {
23 | private final BitmapProvider provider;
24 |
25 | public EmbeddedLinkRenderer(@Nonnull AndroidProcessor processor) {
26 | this(processor, defaultBitmapProvider);
27 | }
28 |
29 | public EmbeddedLinkRenderer(@Nonnull AndroidProcessor processor, BitmapProvider provider) {
30 | super(processor);
31 | this.provider = provider;
32 | }
33 |
34 | @Override public boolean canRender(@Nullable AndroidContext context, @Nonnull CDARichNode node) {
35 | return node instanceof CDARichEmbeddedInline;
36 | }
37 |
38 | @Override protected View inflateRichLayout(@Nonnull AndroidContext context, @Nonnull CDARichNode node) {
39 | final View embedded = context.getInflater().inflate(R.layout.rich_embedded_layout, null, false);
40 | final ViewGroup content = embedded.findViewById(R.id.rich_content);
41 |
42 | final CDARichEmbeddedInline link = (CDARichEmbeddedInline) node;
43 | final Object data = link.getData();
44 |
45 | final View toBeEmbedded;
46 | if (data instanceof CDAEntry) {
47 | final CDAEntry entry = (CDAEntry) data;
48 |
49 | final TextView textView = new TextView(context.getAndroidContext());
50 | textView.setText(entry.getField("title"));
51 |
52 | toBeEmbedded = textView;
53 | } else if (data instanceof CDAAsset) {
54 | final CDAAsset asset = (CDAAsset) data;
55 | final ImageView image = new ImageView(context.getAndroidContext());
56 | image.setImageBitmap(provider.provide(context.getAndroidContext(), asset));
57 |
58 | toBeEmbedded = image;
59 | } else {
60 | final TextView textView = new TextView(context.getAndroidContext());
61 | textView.setText("⚠️");
62 |
63 | toBeEmbedded = textView;
64 | }
65 |
66 | content.addView(toBeEmbedded, 0);
67 | return embedded;
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/views/HorizontalRuleRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.views;
2 |
3 | import android.view.View;
4 |
5 | import com.contentful.java.cda.rich.CDARichHorizontalRule;
6 | import com.contentful.java.cda.rich.CDARichNode;
7 | import com.contentful.rich.android.AndroidContext;
8 | import com.contentful.rich.android.AndroidProcessor;
9 | import com.contentful.rich.android.AndroidRenderer;
10 | import com.contentful.rich.android.R;
11 |
12 | import javax.annotation.Nonnull;
13 | import javax.annotation.Nullable;
14 |
15 | /**
16 | * This renderer will render a rich text node into a TextView, respecting it's marks.
17 | */
18 | public class HorizontalRuleRenderer extends AndroidRenderer {
19 | /**
20 | * Constructor taking a processor for child processing.
21 | *
22 | * Since CDARichText do not have children, the parameter will be ignored.
23 | *
24 | * @param processor used for subrendering of children.
25 | */
26 | public HorizontalRuleRenderer(@Nonnull AndroidProcessor processor) {
27 | super(processor);
28 | }
29 |
30 | /**
31 | * Is the incoming node a horizontal rule?
32 | *
33 | * @param context context this check should be performed in
34 | * @param node node to be checked
35 | * @return true if the node is a rich rule node.
36 | */
37 | @Override public boolean canRender(@Nullable AndroidContext context, @Nonnull CDARichNode node) {
38 | return node instanceof CDARichHorizontalRule;
39 | }
40 |
41 | /**
42 | * Creates a horizontal line.
43 | *
44 | * @param context the generic context this node should be rendered in.
45 | * @param node the node to be rendered.
46 | * @return a view representing a horizontal line.
47 | */
48 | @Nullable @Override public View render(@Nonnull AndroidContext context, @Nonnull CDARichNode node) {
49 | return context.getInflater().inflate(R.layout.rich_horizontal_rule_layout, null);
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/views/ListRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.views;
2 |
3 | import android.text.SpannableStringBuilder;
4 | import android.view.View;
5 | import android.view.ViewGroup;
6 | import android.widget.TextView;
7 | import com.contentful.java.cda.rich.CDARichBlock;
8 | import com.contentful.java.cda.rich.CDARichList;
9 | import com.contentful.java.cda.rich.CDARichListItem;
10 | import com.contentful.java.cda.rich.CDARichNode;
11 | import com.contentful.rich.android.AndroidContext;
12 | import com.contentful.rich.android.AndroidProcessor;
13 | import com.contentful.rich.android.R;
14 | import com.contentful.rich.android.renderer.listdecorator.Decorator;
15 |
16 | import javax.annotation.Nonnull;
17 | import javax.annotation.Nullable;
18 | import java.util.ArrayList;
19 | import java.util.Arrays;
20 | import java.util.HashMap;
21 | import java.util.List;
22 | import java.util.Map;
23 |
24 | public class ListRenderer extends BlockRenderer {
25 |
26 | private final Map decoratorBySymbolMap = new HashMap<>();
27 | private final List decorators = new ArrayList<>();
28 |
29 | public ListRenderer(@Nonnull AndroidProcessor processor, @Nonnull Decorator... decorators) {
30 | super(processor);
31 |
32 | this.decorators.addAll(Arrays.asList(decorators));
33 |
34 | for (final Decorator decorator : decorators) {
35 | this.decoratorBySymbolMap.put(decorator.getSymbol().toString(), decorator);
36 | }
37 | }
38 |
39 | @Override public boolean canRender(@Nullable AndroidContext context, @Nonnull CDARichNode node) {
40 | if (context != null && node instanceof CDARichListItem) {
41 | final CDARichList list = context.getTopListOfPath();
42 | if (list != null) {
43 | return decoratorBySymbolMap.containsKey(list.getDecoration().toString());
44 | }
45 | }
46 |
47 | return false;
48 | }
49 |
50 | @Nullable @Override public View render(@Nonnull AndroidContext context, @Nonnull CDARichNode node) {
51 | final CDARichBlock block = (CDARichBlock) node;
52 | final ViewGroup result = (ViewGroup) context.getInflater().inflate(R.layout.rich_list_layout, null, false);
53 | provideDecoration(context, result, node);
54 |
55 | final ViewGroup content = result.findViewById(R.id.rich_content);
56 |
57 | TextView lastTextView = null;
58 | for (final CDARichNode childNode : block.getContent()) {
59 | final View childView = processor.process(context, childNode);
60 |
61 | if (childView != null) {
62 | if (childView instanceof TextView) {
63 | final TextView childTextView = (TextView) childView;
64 | if (lastTextView != null) {
65 | lastTextView.setText(
66 | new SpannableStringBuilder(lastTextView.getText()).append(childTextView.getText())
67 | );
68 | if(childTextView.getMovementMethod() != null) {
69 | lastTextView.setMovementMethod(childTextView.getMovementMethod());
70 | }
71 | } else {
72 | lastTextView = childTextView;
73 | content.addView(childView);
74 | }
75 | } else {
76 | content.addView(childView);
77 | }
78 | }
79 | }
80 |
81 | return result;
82 | }
83 |
84 | protected void provideDecoration(@Nonnull AndroidContext context, @Nonnull ViewGroup group, @Nonnull CDARichNode node) {
85 | final TextView decoration = group.findViewById(R.id.rich_list_decoration);
86 |
87 | final List path = context.getPath();
88 | CDARichList list = context.getTopListOfPath();
89 | final Decorator currentDecorator;
90 | final int childIndex;
91 | if (list == null) {
92 | list = (CDARichList) node;
93 | childIndex = 0;
94 | currentDecorator = decoratorBySymbolMap.get(list.getDecoration());
95 | } else {
96 | final int listIndex = path.indexOf(list);
97 | final int listItemIndexOnPath = listIndex + 1;
98 | childIndex = list.getContent().indexOf(path.get(listItemIndexOnPath));
99 |
100 | final int nestedListCount = (int) (getListOfTypeCount(context, list)) % Integer.MAX_VALUE;
101 |
102 | final Decorator initialDecorator = decoratorBySymbolMap.get(list.getDecoration().toString());
103 | final int initialDecoratorIndex = decorators.indexOf(initialDecorator);
104 | int currentPosition = ((initialDecoratorIndex + nestedListCount) % decorators.size()) - 1;
105 | if(currentPosition < 0) {
106 | currentPosition = 0;
107 | }
108 |
109 | currentDecorator = decorators.get(currentPosition);
110 | }
111 |
112 |
113 | decoration.setText(currentDecorator.decorate(childIndex + 1));
114 | }
115 |
116 | /**
117 | * Count lists on the path.
118 | *
119 | * @param context where is the path stored in? The context!
120 | * @param list the list to be listed.
121 | * @return the number of lists of the supported type.
122 | */
123 | private long getListOfTypeCount(@Nonnull AndroidContext context, CDARichList list) {
124 | if (context.getPath() == null) {
125 | return 0;
126 | }
127 | int count = 0;
128 | for (CDARichNode node: context.getPath()) {
129 | if (node instanceof CDARichList && ((CDARichList) node).getDecoration().equals(list.getDecoration())) {
130 | count++;
131 | }
132 | }
133 | return count;
134 | }
135 |
136 | }
137 |
--------------------------------------------------------------------------------
/android/src/main/java/com/contentful/rich/android/renderer/views/NativeViewsRendererProvider.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.android.renderer.views;
2 |
3 | import android.view.View;
4 |
5 | import com.contentful.rich.android.AndroidProcessor;
6 | import com.contentful.rich.android.renderer.listdecorator.BulletDecorator;
7 | import com.contentful.rich.android.renderer.listdecorator.LowerCaseCharacterDecorator;
8 | import com.contentful.rich.android.renderer.listdecorator.LowerCaseRomanNumeralsDecorator;
9 | import com.contentful.rich.android.renderer.listdecorator.NumbersDecorator;
10 | import com.contentful.rich.android.renderer.listdecorator.UpperCaseCharacterDecorator;
11 | import com.contentful.rich.android.renderer.listdecorator.UpperCaseRomanNumeralsDecorator;
12 |
13 | import javax.annotation.Nonnull;
14 |
15 | /**
16 | * Provider for all native renderers.
17 | */
18 | public class NativeViewsRendererProvider {
19 | /**
20 | * Fill up the given processor with the default renderers supporting native views.
21 | *
22 | * @param processor the processor to be augmented.
23 | */
24 | public void provide(@Nonnull AndroidProcessor processor) {
25 | processor.addRenderer(new TextRenderer(processor));
26 | processor.addRenderer(new HorizontalRuleRenderer(processor));
27 | processor.addRenderer(new ListRenderer(processor, new BulletDecorator()));
28 | processor.addRenderer(new ListRenderer(processor,
29 | new NumbersDecorator(),
30 | new UpperCaseCharacterDecorator(),
31 | new LowerCaseRomanNumeralsDecorator(),
32 | new LowerCaseCharacterDecorator(),
33 | new LowerCaseCharacterDecorator(),
34 | new UpperCaseRomanNumeralsDecorator()
35 | ));
36 | processor.addRenderer(new HyperLinkRenderer(processor));
37 | processor.addRenderer(new QuoteRenderer(processor));
38 | processor.addRenderer(new TableRenderer(processor));
39 | processor.addRenderer(new BlockRenderer(processor));
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/android/src/main/res/drawable-night/table_header_cell_border.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | -
4 |
5 |
6 |
7 |
8 | -
9 |
10 |
11 |
12 |
13 | -
14 |
15 |
16 |
17 |
18 |
--------------------------------------------------------------------------------
/android/src/main/res/drawable/quote_background.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
9 |
14 |
--------------------------------------------------------------------------------
/android/src/main/res/drawable/table_border.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
7 |
8 |
--------------------------------------------------------------------------------
/android/src/main/res/drawable/table_cell_border.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | -
4 |
5 |
6 |
7 |
8 | -
9 |
10 |
11 |
12 |
13 |
--------------------------------------------------------------------------------
/android/src/main/res/drawable/table_divider.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/android/src/main/res/drawable/table_header_cell_border.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | -
4 |
5 |
6 |
7 |
8 | -
9 |
10 |
11 |
12 |
13 | -
14 |
15 |
16 |
17 |
18 |
--------------------------------------------------------------------------------
/android/src/main/res/layout/rich_block_layout.xml:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/android/src/main/res/layout/rich_embedded_layout.xml:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
18 |
19 |
28 |
29 |
--------------------------------------------------------------------------------
/android/src/main/res/layout/rich_horizontal_rule_layout.xml:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 |
14 |
15 |
--------------------------------------------------------------------------------
/android/src/main/res/layout/rich_hyperlink_layout.xml:
--------------------------------------------------------------------------------
1 |
2 |
8 |
9 |
17 |
18 |
27 |
--------------------------------------------------------------------------------
/android/src/main/res/layout/rich_indention_layout.xml:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
16 |
17 |
18 |
--------------------------------------------------------------------------------
/android/src/main/res/layout/rich_list_layout.xml:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
20 |
21 |
28 |
29 |
--------------------------------------------------------------------------------
/android/src/main/res/layout/rich_quote_layout.xml:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 |
15 |
16 |
--------------------------------------------------------------------------------
/android/src/main/res/layout/rich_table_cell_layout.xml:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 |
23 |
--------------------------------------------------------------------------------
/android/src/main/res/layout/rich_table_layout.xml:
--------------------------------------------------------------------------------
1 |
2 |
12 |
19 |
20 |
21 |
--------------------------------------------------------------------------------
/android/src/main/res/layout/rich_text_layout.xml:
--------------------------------------------------------------------------------
1 |
2 |
16 |
--------------------------------------------------------------------------------
/android/src/main/res/values/ids.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
17 | * Use {@see #addRenderer} for adding more low level renders on it or use one of the extension
18 | * modules.
19 | *
20 | * @param the context type used throughout this rendering process.
21 | * @param the result type of the rendering process.
22 | * @see Renderer
23 | * @see RenderabilityChecker
24 | */
25 | public class Processor {
26 |
27 | @Nonnull
28 | private final List> nodeRenderer = new ArrayList<>();
29 |
30 | /**
31 | * Create a new empty processor.
32 | */
33 | public Processor() {
34 | }
35 |
36 | /**
37 | * Add a renderer to the end of the list of available renders.
38 | *
39 | * If a renderer before hand matches the node, the new renderer might not be executed. If you want
40 | * to make sure your renderer is considered first, either {@see #reset} the list of renderer, or
41 | * {@see #overrideRenderer} to make your renderer the first to be checked, overriding other
42 | * renderer added.
43 | *
44 | * @param renderer may not be null.
45 | * @return this renderer for chaining.
46 | */
47 | @Nonnull
48 | public Processor addRenderer(@Nonnull RenderabilityChecker checker, @Nonnull Renderer renderer) {
49 | nodeRenderer.add(new CheckingRenderer<>(checker, renderer));
50 | return this;
51 | }
52 |
53 | /**
54 | * Adds the renderer to the front of the list of renderer, overriding similar renderer if needed.
55 | *
56 | * @param renderer may not be null.
57 | * @return this renderer for chaining.
58 | */
59 | @Nonnull
60 | public Processor overrideRenderer(@Nonnull RenderabilityChecker checker, @Nonnull Renderer renderer) {
61 | nodeRenderer.add(0, new CheckingRenderer<>(checker, renderer));
62 | return this;
63 | }
64 |
65 | /**
66 | * Start the node rendering process.
67 | *
68 | * This process will process the node and all of it's child nodes by using the added renderer.
69 | *
70 | * @param node a not null node to be rendered.
71 | * @return the result in the form given by the renderer.
72 | */
73 | @Nullable public R process(@Nonnull C context, @Nonnull CDARichNode node) {
74 | if (node instanceof CDARichBlock) {
75 | context.onBlockEntered((CDARichBlock) node);
76 | }
77 |
78 | R result = null;
79 | for (final CheckingRenderer pair : nodeRenderer) {
80 | final RenderabilityChecker checker = pair.checker;
81 |
82 | if (checker.canRender(context, node)) {
83 | final Renderer renderer = pair.renderer;
84 | result = renderer.render(context, node);
85 | if (result != null) {
86 | break;
87 | }
88 | }
89 | }
90 |
91 | if (node instanceof CDARichBlock) {
92 | context.onBlockExited((CDARichBlock) node);
93 | }
94 |
95 | return result;
96 | }
97 |
98 | /**
99 | * Internal class for combining checkers and renderer.
100 | *
101 | * @param Custom context class
102 | * @param Result class of the rendering
103 | */
104 | private static class CheckingRenderer {
105 | final RenderabilityChecker checker;
106 | final Renderer renderer;
107 |
108 | /**
109 | * Construct a new CheckerRenderer
110 | *
111 | * @param checker the checker to be used
112 | * @param renderer the renderer to be checked
113 | */
114 | CheckingRenderer(@Nonnull RenderabilityChecker checker, @Nonnull Renderer renderer) {
115 | this.checker = checker;
116 | this.renderer = renderer;
117 | }
118 | }
119 | }
120 |
--------------------------------------------------------------------------------
/core/src/main/java/com/contentful/rich/core/RenderabilityChecker.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.core;
2 |
3 | import com.contentful.java.cda.rich.CDARichNode;
4 |
5 | import javax.annotation.Nonnull;
6 | import javax.annotation.Nullable;
7 |
8 | /**
9 | * Implementer of this interface will be able to tell if a given node can be rendered in the given
10 | * context.
11 | *
12 | * @param Custom Context Class
13 | * @see Renderer
14 | */
15 | public interface RenderabilityChecker {
16 |
17 | /**
18 | * Return true if the associated renderer can process the node.
19 | *
20 | * @param context context this check should be performed in
21 | * @param node node to be checked
22 | * @return false if the renderer cannot be used.
23 | */
24 | boolean canRender(@Nullable C context, @Nonnull CDARichNode node);
25 | }
26 |
--------------------------------------------------------------------------------
/core/src/main/java/com/contentful/rich/core/Renderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.core;
2 |
3 | import com.contentful.java.cda.rich.CDARichNode;
4 |
5 | import javax.annotation.Nonnull;
6 | import javax.annotation.Nullable;
7 |
8 | /**
9 | * Implementing classes of this interface will control how the given node will be rendered in the
10 | * given Context.
11 | *
12 | * @param the custom context class to passed
13 | * @param the result type of the rendering
14 | * @see RenderabilityChecker
15 | */
16 | public interface Renderer {
17 | /**
18 | * Renders the given node in the given context.
19 | *
20 | * @param context the generic context this node should be rendered in.
21 | * @param node the node to be rendered.
22 | * @return the rendered node, unless this renderer encountered an error.
23 | */
24 | @Nullable R render(
25 | @Nonnull C context,
26 | @Nonnull CDARichNode node
27 | );
28 | }
29 |
--------------------------------------------------------------------------------
/core/src/main/java/com/contentful/rich/core/simple/RemoveEmpties.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.core.simple;
2 |
3 | import com.contentful.java.cda.rich.CDARichBlock;
4 | import com.contentful.java.cda.rich.CDARichHorizontalRule;
5 | import com.contentful.java.cda.rich.CDARichHyperLink;
6 | import com.contentful.java.cda.rich.CDARichNode;
7 | import com.contentful.java.cda.rich.CDARichText;
8 |
9 | import java.util.ArrayList;
10 | import java.util.List;
11 |
12 | /**
13 | * This simplification removes all empty nodes, may it be leaf or internal nodes.
14 | *
15 | * An empty text node will get removed from it's parent node, as well as a inner node, who just wraps a node.
16 | */
17 | public class RemoveEmpties implements Simplification {
18 |
19 | /**
20 | * Return a node without step stone or empty nodes.
21 | *
22 | * @param node the graph root node to start simplification on.
23 | * @return the simplified graph.
24 | */
25 | @Override public CDARichNode simplify(CDARichNode node) {
26 | if (node instanceof CDARichBlock) {
27 | return simplifyBlocks((CDARichBlock) node);
28 | } else if (node instanceof CDARichText) {
29 | return simplifyTextNode((CDARichText) node);
30 | } else if (node instanceof CDARichHorizontalRule) {
31 | return node;
32 | } else if (node != null) {
33 | throw new IllegalStateException("Non mapped node of type " + node.getClass().getSimpleName() + " found.");
34 | } else {
35 | throw new IllegalStateException("Cannot simplify null nodes!");
36 | }
37 | }
38 |
39 | private CDARichNode simplifyTextNode(CDARichText text) {
40 | if (text.getText() == null || text.getText().length() == 0) {
41 | return null;
42 | } else {
43 | return text;
44 | }
45 | }
46 |
47 | private CDARichBlock simplifyBlocks(CDARichBlock block) {
48 | if (block == null) {
49 | return null;
50 | }
51 |
52 | if (block.getContent().size() == 0 && !(block instanceof CDARichHyperLink)) {
53 | return null;
54 | } else if (block.getContent().size() == 1 && block.getContent().get(0).getClass().equals(block.getClass())) {
55 | return simplifyBlocks(simplifyBlocks((CDARichBlock) block.getContent().get(0)));
56 | } else {
57 | final List simplifiedChildren = new ArrayList<>();
58 | for (final CDARichNode node : block.getContent()) {
59 | final CDARichNode simplified = simplify(node);
60 | if (simplified != null) {
61 | simplifiedChildren.add(simplified);
62 | }
63 | }
64 |
65 | if (simplifiedChildren.size() == 0 && !(block instanceof CDARichHyperLink)) {
66 | return null;
67 | } else {
68 | block.getContent().clear();
69 | block.getContent().addAll(simplifiedChildren);
70 | return block;
71 | }
72 | }
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/core/src/main/java/com/contentful/rich/core/simple/RemoveToDeepNesting.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.core.simple;
2 |
3 | import com.contentful.java.cda.rich.CDARichBlock;
4 | import com.contentful.java.cda.rich.CDARichHyperLink;
5 | import com.contentful.java.cda.rich.CDARichNode;
6 |
7 | import java.util.ArrayList;
8 | import java.util.List;
9 |
10 | /**
11 | * This simplification will remove all nodes below a given nesting level. If more then the given amount of depth is
12 | * reached, no children will be present.
13 | *
14 | * This simplification is best to be used first in the chain of simplifications, so that subsequent simplifications can
15 | * work on an already reduced graph.
16 | */
17 | public class RemoveToDeepNesting implements Simplification {
18 |
19 | private static final int DEFAULT_LEVEL_DEPTH = 4;
20 | private final int level;
21 |
22 | /**
23 | * Create a simplification using {@link #DEFAULT_LEVEL_DEPTH} number of levels.
24 | */
25 | public RemoveToDeepNesting() {
26 | this(DEFAULT_LEVEL_DEPTH);
27 | }
28 |
29 | /**
30 | * Create a simplification using custom number of levels as a maximum.
31 | *
32 | * @param level
33 | */
34 | public RemoveToDeepNesting(int level) {
35 | this.level = level;
36 | }
37 |
38 | /**
39 | * Start the heavy lifting of reducing the graph.
40 | *
41 | * @param node the graph root node to start simplification on.
42 | * @return the reduced graph.
43 | */
44 | @Override public CDARichNode simplify(CDARichNode node) {
45 | return simplifyByLevel(node, level);
46 | }
47 |
48 | private CDARichNode simplifyByLevel(CDARichNode node, int level) {
49 | if (level <= 0) {
50 | return null;
51 | }
52 |
53 | if (node == null) {
54 | return null;
55 | }
56 |
57 | if (node instanceof CDARichBlock) {
58 | final CDARichBlock block = (CDARichBlock) node;
59 | final List simplifiedChildren = new ArrayList<>();
60 | for (final CDARichNode contentNode : block.getContent()) {
61 | final CDARichNode simplified = simplifyByLevel(contentNode, level - 1);
62 | if (simplified != null) {
63 | simplifiedChildren.add(simplified);
64 | }
65 | }
66 |
67 | if (simplifiedChildren.size() == 0 && !(block instanceof CDARichHyperLink)) {
68 | return null;
69 | } else {
70 | block.getContent().clear();
71 | block.getContent().addAll(simplifiedChildren);
72 | return block;
73 | }
74 | }
75 |
76 | return node;
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/core/src/main/java/com/contentful/rich/core/simple/Simplification.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.core.simple;
2 |
3 | import com.contentful.java.cda.rich.CDARichNode;
4 |
5 | /**
6 | * This interface specifies a simplification: An option to be done on the graph of rich text nodes.
7 | */
8 | public interface Simplification {
9 | /**
10 | * Simplify the given graph pointed to by node.
11 | * @param node the graph root node to start simplification on.
12 | * @return a simplified node graph.
13 | */
14 | CDARichNode simplify(CDARichNode node);
15 | }
16 |
--------------------------------------------------------------------------------
/core/src/main/java/com/contentful/rich/core/simple/Simplifier.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.core.simple;
2 |
3 | import com.contentful.java.cda.rich.CDARichNode;
4 |
5 | /**
6 | * This class will be used to simplify a given graph of rich text nodes, so only non empty nodes survive.
7 | */
8 | public class Simplifier {
9 |
10 | private final Simplification[] simplifications;
11 |
12 | /**
13 | * Create a simplifier removing empties.
14 | */
15 | public Simplifier() {
16 | this(new RemoveEmpties());
17 | }
18 |
19 | /**
20 | * Construct a custom simplifier applying custom simplifications.
21 | *
22 | * @param simplifications to be applied on the graph.
23 | */
24 | public Simplifier(Simplification... simplifications) {
25 | if (simplifications == null || simplifications.length == 0) {
26 | this.simplifications = new Simplification[]{new RemoveEmpties()};
27 | } else {
28 | this.simplifications = simplifications;
29 | }
30 | }
31 |
32 | /**
33 | * This method does the heavy lifting of reducing the graph.
34 | *
35 | * @param node the node node to be started to be checked for empty nodes.
36 | * @return a cleaned graph.
37 | */
38 | public CDARichNode simplify(CDARichNode node) {
39 | for (final Simplification simplification : simplifications) {
40 | if (node != null) {
41 | node = simplification.simplify(node);
42 | }
43 | }
44 | return node;
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/core/src/test/java/ComplexProcessorTest.java:
--------------------------------------------------------------------------------
1 | import com.contentful.java.cda.rich.CDARichBlock;
2 | import com.contentful.java.cda.rich.CDARichOrderedList;
3 | import com.contentful.java.cda.rich.CDARichParagraph;
4 | import com.contentful.java.cda.rich.CDARichText;
5 | import com.contentful.java.cda.rich.CDARichUnorderedList;
6 | import com.contentful.rich.core.Context;
7 | import com.contentful.rich.core.Processor;
8 |
9 | import org.junit.Test;
10 |
11 | import java.util.ArrayList;
12 | import java.util.List;
13 |
14 | import javax.annotation.Nonnull;
15 |
16 | import static com.google.common.truth.Truth.assertThat;
17 | import static java.util.stream.Collectors.joining;
18 |
19 | public class ComplexProcessorTest {
20 | @Test
21 | public void complexListRenderingTest() {
22 | final Processor processor = new Processor<>();
23 | final SiblingCountingContext siblingCountingContext = new SiblingCountingContext();
24 | processor.addRenderer(
25 | (context, node) -> node instanceof CDARichBlock,
26 | (context, node) -> ((CDARichBlock) node).getContent().stream().map(block -> processor.process(context, block)).collect(joining("\n"))
27 | );
28 | processor.addRenderer(
29 | (context, node) -> node instanceof CDARichText,
30 | (context, node) -> {
31 | final List path = context.getPath();
32 | final CharSequence text = ((CDARichText) node).getText();
33 | String symbol = path.get(path.size() - 1);
34 | if ("1".equals(symbol)) {
35 | symbol = "1. ";
36 | } else if ("*".equals(symbol)) {
37 | symbol = "* ";
38 | }
39 | final String indentation = path.stream().map((x) -> " ").collect(joining());
40 |
41 | return indentation + symbol + text;
42 | }
43 | );
44 |
45 | final CDARichUnorderedList unorderedList = new CDARichUnorderedList();
46 | unorderedList.getContent().add(new CDARichText("unordered_a", new ArrayList<>()));
47 | unorderedList.getContent().add(new CDARichText("unordered_b", new ArrayList<>()));
48 | unorderedList.getContent().add(new CDARichText("unordered_c", new ArrayList<>()));
49 |
50 | final CDARichOrderedList innerList = new CDARichOrderedList();
51 | innerList.getContent().add(new CDARichText("inner_first", new ArrayList<>()));
52 | innerList.getContent().add(new CDARichText("inner_second", new ArrayList<>()));
53 | innerList.getContent().add(unorderedList);
54 | innerList.getContent().add(new CDARichText("inner_third", new ArrayList<>()));
55 |
56 | final CDARichOrderedList outerList = new CDARichOrderedList();
57 | outerList.getContent().add(new CDARichText("outer_top", new ArrayList<>()));
58 | outerList.getContent().add(innerList);
59 | outerList.getContent().add(new CDARichText("outer_bottom", new ArrayList<>()));
60 |
61 | final CDARichParagraph paragraph = new CDARichParagraph();
62 | paragraph.getContent().add(new CDARichText("first", new ArrayList<>()));
63 | paragraph.getContent().add(new CDARichText("second", new ArrayList<>()));
64 | paragraph.getContent().add(outerList);
65 | paragraph.getContent().add(new CDARichText("last", new ArrayList<>()));
66 |
67 | final String result = processor.process(siblingCountingContext, paragraph);
68 |
69 | assertThat(result).isEqualTo(
70 | " first\n" +
71 | " second\n" +
72 | " 1. outer_top\n" +
73 | " 1. inner_first\n" +
74 | " 1. inner_second\n" +
75 | " * unordered_a\n" +
76 | " * unordered_b\n" +
77 | " * unordered_c\n" +
78 | " 1. inner_third\n" +
79 | " 1. outer_bottom\n" +
80 | " last");
81 | }
82 |
83 | private class SiblingCountingContext extends Context> {
84 | private List path = new ArrayList<>();
85 |
86 | @Override public void onBlockEntered(@Nonnull CDARichBlock block) {
87 | if (block instanceof CDARichOrderedList) {
88 | path.add("1");
89 | } else if (block instanceof CDARichUnorderedList) {
90 | path.add("*");
91 | } else {
92 | path.add("");
93 | }
94 | }
95 |
96 | @Override public void onBlockExited(@Nonnull CDARichBlock block) {
97 | path.remove(path.size() - 1);
98 | }
99 |
100 | @Nonnull @Override public List getPath() {
101 | super.getPath();
102 | return path;
103 | }
104 | }
105 | }
106 |
--------------------------------------------------------------------------------
/core/src/test/java/ProcessorTest.java:
--------------------------------------------------------------------------------
1 | import com.contentful.java.cda.rich.CDARichBlock;
2 | import com.contentful.java.cda.rich.CDARichParagraph;
3 | import com.contentful.java.cda.rich.CDARichText;
4 | import com.contentful.rich.core.Context;
5 | import com.contentful.rich.core.Processor;
6 |
7 | import org.junit.Test;
8 |
9 | import java.util.ArrayList;
10 | import java.util.List;
11 |
12 | import javax.annotation.Nonnull;
13 | import javax.annotation.Nullable;
14 |
15 | import lib.DescendingTextRendererProvider;
16 |
17 | import static com.google.common.truth.Truth.assertThat;
18 | import static junit.framework.TestCase.fail;
19 |
20 | public class ProcessorTest {
21 |
22 | @Test
23 | public void renderTextTest() {
24 | final Processor, CharSequence> processor = new Processor<>();
25 | new DescendingTextRendererProvider().provide(processor);
26 |
27 | final CharSequence result = processor.process(new Context<>(), new CDARichText("Foo", new ArrayList<>()));
28 |
29 | assertThat(result).isEqualTo("Foo");
30 | }
31 |
32 | @Test
33 | public void contextFactoryGetsNotInvolvedInTexts() {
34 | final Processor, CharSequence> processor = new Processor<>();
35 | final Context context = new Context() {
36 | @Override public void onBlockEntered(@Nonnull CDARichBlock paragraph) {
37 | fail("No block to be entered");
38 | }
39 |
40 | @Override public void onBlockExited(@Nonnull CDARichBlock block) {
41 | fail("No block to be exited");
42 | }
43 |
44 | @Override @Nonnull public String getPath() {
45 | return "Context!";
46 | }
47 | };
48 |
49 | new DescendingTextRendererProvider().provide(processor);
50 |
51 | final CharSequence result = processor.process(context, new CDARichText("Foo", new ArrayList<>()));
52 | assertThat(result).isEqualTo("Foo");
53 | }
54 |
55 | @Test
56 | public void nestingTest() {
57 | final Processor, CharSequence> processor = new Processor<>();
58 | new DescendingTextRendererProvider().provide(processor);
59 |
60 | final CDARichParagraph paragraph = new CDARichParagraph();
61 | paragraph.getContent().add(new CDARichText("Foo", new ArrayList<>()));
62 |
63 | final CharSequence result = processor.process(new Context<>(), paragraph);
64 | assertThat(result).isEqualTo("--Foo");
65 | }
66 |
67 | @Test
68 | public void contextFactoryMethodsAreCalledTest() {
69 | final List events = new ArrayList<>();
70 |
71 | final Processor, CharSequence> processor = new Processor<>();
72 | final Context context = new Context() {
73 | @Override public void onBlockEntered(@Nonnull CDARichBlock block) {
74 | events.add("entered");
75 | }
76 |
77 | @Override public void onBlockExited(@Nonnull CDARichBlock block) {
78 | events.add("exited");
79 | }
80 |
81 | @Nullable @Override public String getPath() {
82 | return null;
83 | }
84 | };
85 |
86 | new DescendingTextRendererProvider().provide(processor);
87 |
88 | final CDARichParagraph paragraph = new CDARichParagraph();
89 | paragraph.getContent().add(new CDARichText("constant text", new ArrayList<>()));
90 | paragraph.getContent().add(new CDARichText("constant text", new ArrayList<>()));
91 | paragraph.getContent().add(new CDARichParagraph());
92 |
93 | processor.process(context, paragraph);
94 |
95 | assertThat(events).containsAllIn(new String[]{"entered", "entered", "exited", "exited"});
96 | }
97 |
98 | }
99 |
--------------------------------------------------------------------------------
/core/src/test/java/RendererOrderTest.java:
--------------------------------------------------------------------------------
1 | import com.contentful.java.cda.rich.CDARichNode;
2 | import com.contentful.rich.core.Context;
3 | import com.contentful.rich.core.Processor;
4 |
5 | import org.junit.Before;
6 | import org.junit.Test;
7 |
8 | import static com.google.common.truth.Truth.assertThat;
9 |
10 | public class RendererOrderTest {
11 | Processor, String> processor;
12 |
13 | @Before
14 | public void setup() {
15 | processor = new Processor<>();
16 | processor.addRenderer(
17 | (context, node) -> true,
18 | (context, node) -> "catch all"
19 | );
20 | }
21 |
22 | @Test
23 | public void overrideRenderer() {
24 | processor.overrideRenderer(
25 | (context, node) -> true,
26 | (context, node) -> "overridden"
27 | );
28 |
29 | final String result = processor.process(new Context<>(), new CDARichNode());
30 | assertThat(result).isEqualTo("overridden");
31 | }
32 |
33 | @Test
34 | public void addButNotOverride() {
35 | processor.addRenderer(
36 | (context, node) -> true,
37 | (context, node) -> "not overridden"
38 | );
39 |
40 | final String result = processor.process(new Context<>(), new CDARichNode());
41 | assertThat(result).isEqualTo("catch all");
42 | }
43 |
44 | }
45 |
--------------------------------------------------------------------------------
/core/src/test/java/SimplifierTest.java:
--------------------------------------------------------------------------------
1 | import com.contentful.java.cda.rich.CDARichDocument;
2 | import com.contentful.java.cda.rich.CDARichNode;
3 | import com.contentful.java.cda.rich.CDARichParagraph;
4 | import com.contentful.java.cda.rich.CDARichText;
5 | import com.contentful.rich.core.simple.RemoveEmpties;
6 | import com.contentful.rich.core.simple.RemoveToDeepNesting;
7 | import com.contentful.rich.core.simple.Simplifier;
8 |
9 | import org.junit.Test;
10 |
11 | import static com.google.common.truth.Truth.assertThat;
12 | import static java.util.Collections.emptyList;
13 |
14 | public class SimplifierTest {
15 | @Test
16 | public void removeDirectEmptyNodes() {
17 | final CDARichDocument document = new CDARichDocument();
18 | document.getContent().add(new CDARichParagraph());
19 | document.getContent().add(new CDARichText("only one there", emptyList()));
20 |
21 | final CDARichNode simplified = new Simplifier().simplify(document);
22 |
23 | assertThat(simplified).isInstanceOf(CDARichDocument.class);
24 |
25 | final CDARichDocument simplifiedDocument = (CDARichDocument) simplified;
26 | assertThat((simplifiedDocument.getContent())).hasSize(1);
27 | assertThat(simplifiedDocument.getContent().get(0)).isInstanceOf(CDARichText.class);
28 | assertThat(((CDARichText) simplifiedDocument.getContent().get(0)).getText()).isEqualTo("only one there");
29 | }
30 |
31 | @Test
32 | public void removeEmptyParentsNodes() {
33 | final CDARichDocument document = new CDARichDocument();
34 |
35 | final CDARichParagraph emptyParent = new CDARichParagraph();
36 | emptyParent.getContent().add(new CDARichParagraph());
37 |
38 | document.getContent().add(emptyParent);
39 | document.getContent().add(new CDARichText("only one there", emptyList()));
40 |
41 | final CDARichDocument simplified = (CDARichDocument) new Simplifier().simplify(document);
42 |
43 | assertThat(simplified).isInstanceOf(CDARichDocument.class);
44 |
45 | assertThat((simplified.getContent())).hasSize(1);
46 | assertThat(simplified.getContent().get(0)).isInstanceOf(CDARichText.class);
47 | assertThat(((CDARichText) simplified.getContent().get(0)).getText()).isEqualTo("only one there");
48 | }
49 |
50 | @Test
51 | public void oneElementBlockInABlockRemovedInnerBlock() {
52 | final CDARichDocument document = new CDARichDocument();
53 |
54 | final CDARichParagraph first = new CDARichParagraph();
55 |
56 | final CDARichParagraph second = new CDARichParagraph();
57 | second.getContent().add(new CDARichText("only one there", emptyList()));
58 |
59 | first.getContent().add(second);
60 |
61 | document.getContent().add(first);
62 |
63 | final CDARichDocument simplified = (CDARichDocument) new Simplifier().simplify(document);
64 |
65 | assertThat((simplified.getContent())).hasSize(1);
66 | assertThat(simplified.getContent().get(0)).isInstanceOf(CDARichParagraph.class);
67 | final CDARichParagraph paragraph = (CDARichParagraph) simplified.getContent().get(0);
68 | assertThat(paragraph.getContent().get(0)).isInstanceOf(CDARichText.class);
69 | assertThat(((CDARichText) paragraph.getContent().get(0)).getText()).isEqualTo("only one there");
70 | }
71 |
72 | @Test
73 | public void nullifySingleEmptyTextNode() {
74 | final CDARichNode simplified = new Simplifier().simplify(new CDARichText(null, emptyList()));
75 |
76 | assertThat(simplified).isNull();
77 | }
78 |
79 | @Test
80 | public void simplifyByGraphDepth() {
81 | final CDARichDocument document = new CDARichDocument();
82 |
83 | final CDARichParagraph first = new CDARichParagraph();
84 | final CDARichParagraph second = new CDARichParagraph();
85 | final CDARichParagraph third = new CDARichParagraph();
86 | third.getContent().add(new CDARichText("this should be removed", emptyList()));
87 |
88 | second.getContent().add(third);
89 | first.getContent().add(second);
90 |
91 | document.getContent().add(first);
92 | document.getContent().add(new CDARichText("only one there", emptyList()));
93 |
94 | final CDARichDocument simplified = (CDARichDocument) new Simplifier(
95 | new RemoveToDeepNesting(),
96 | new RemoveEmpties()
97 | ).simplify(document);
98 |
99 | assertThat((simplified.getContent())).hasSize(1);
100 | assertThat(simplified.getContent().get(0)).isInstanceOf(CDARichText.class);
101 | assertThat(((CDARichText) simplified.getContent().get(0)).getText()).isEqualTo("only one there");
102 | }
103 | }
104 |
--------------------------------------------------------------------------------
/core/src/test/java/lib/ContentfulCreator.java:
--------------------------------------------------------------------------------
1 | package lib;
2 |
3 | import com.contentful.java.cda.CDAEntry;
4 | import com.contentful.java.cda.CDAResource;
5 |
6 | import java.lang.reflect.Field;
7 |
8 | import static com.google.common.collect.Maps.newHashMap;
9 |
10 | public class ContentfulCreator {
11 | public static CDAResource mockCDAEntry() {
12 | final CDAEntry entry = new CDAEntry();
13 | Field attrs = null;
14 | for (final Field field : CDAResource.class.getDeclaredFields()) {
15 | if ("attrs".equals(field.getName())) {
16 | attrs = field;
17 | }
18 | }
19 | if (attrs != null) {
20 | attrs.setAccessible(true);
21 | try {
22 | attrs.set(entry, newHashMap());
23 | } catch (IllegalAccessException e) {
24 | }
25 | attrs.setAccessible(false);
26 | }
27 |
28 | entry.attrs().put("id", "fake_id");
29 | entry.attrs().put("contentType", "fake_type");
30 | return entry;
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/core/src/test/java/lib/DescendingTextRendererProvider.java:
--------------------------------------------------------------------------------
1 | package lib;
2 |
3 | import com.contentful.java.cda.rich.CDARichParagraph;
4 | import com.contentful.java.cda.rich.CDARichText;
5 | import com.contentful.rich.core.Context;
6 | import com.contentful.rich.core.Processor;
7 |
8 | import java.util.stream.Collectors;
9 |
10 | import javax.annotation.Nonnull;
11 |
12 | public class DescendingTextRendererProvider {
13 | public void provide(@Nonnull Processor, CharSequence> processor) {
14 | processor.addRenderer(
15 | (context, node) -> node instanceof CDARichText,
16 | (context, node) -> ((CDARichText) node).getText()
17 | );
18 |
19 | processor.addRenderer(
20 | (context, node) -> node instanceof CDARichParagraph,
21 | (context, node) -> {
22 | final CDARichParagraph block = (CDARichParagraph) node;
23 | return "--" + block.getContent().stream().map(innerBlock -> processor.process(context, innerBlock)).collect(Collectors.joining());
24 | }
25 | );
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
1 | android.enableJetifier=true
2 | android.useAndroidX=true
3 | org.gradle.jvmargs=-XX:MaxMetaspaceSize=512m
4 |
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/contentful/rich-text-renderer-java/a1502f736dce6c1a1c2f0efae42d278eefc82304/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Tue May 27 19:53:15 CEST 2025
2 | distributionBase=GRADLE_USER_HOME
3 | distributionPath=wrapper/dists
4 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
5 | zipStoreBase=GRADLE_USER_HOME
6 | zipStorePath=wrapper/dists
7 |
--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
1 | @if "%DEBUG%" == "" @echo off
2 | @rem ##########################################################################
3 | @rem
4 | @rem Gradle startup script for Windows
5 | @rem
6 | @rem ##########################################################################
7 |
8 | @rem Set local scope for the variables with windows NT shell
9 | if "%OS%"=="Windows_NT" setlocal
10 |
11 | set DIRNAME=%~dp0
12 | if "%DIRNAME%" == "" set DIRNAME=.
13 | set APP_BASE_NAME=%~n0
14 | set APP_HOME=%DIRNAME%
15 |
16 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
17 | set DEFAULT_JVM_OPTS=
18 |
19 | @rem Find java.exe
20 | if defined JAVA_HOME goto findJavaFromJavaHome
21 |
22 | set JAVA_EXE=java.exe
23 | %JAVA_EXE% -version >NUL 2>&1
24 | if "%ERRORLEVEL%" == "0" goto init
25 |
26 | echo.
27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
28 | echo.
29 | echo Please set the JAVA_HOME variable in your environment to match the
30 | echo location of your Java installation.
31 |
32 | goto fail
33 |
34 | :findJavaFromJavaHome
35 | set JAVA_HOME=%JAVA_HOME:"=%
36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
37 |
38 | if exist "%JAVA_EXE%" goto init
39 |
40 | echo.
41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
42 | echo.
43 | echo Please set the JAVA_HOME variable in your environment to match the
44 | echo location of your Java installation.
45 |
46 | goto fail
47 |
48 | :init
49 | @rem Get command-line arguments, handling Windows variants
50 |
51 | if not "%OS%" == "Windows_NT" goto win9xME_args
52 |
53 | :win9xME_args
54 | @rem Slurp the command line arguments.
55 | set CMD_LINE_ARGS=
56 | set _SKIP=2
57 |
58 | :win9xME_args_slurp
59 | if "x%~1" == "x" goto execute
60 |
61 | set CMD_LINE_ARGS=%*
62 |
63 | :execute
64 | @rem Setup the command line
65 |
66 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
67 |
68 | @rem Execute Gradle
69 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
70 |
71 | :end
72 | @rem End local scope for the variables with windows NT shell
73 | if "%ERRORLEVEL%"=="0" goto mainEnd
74 |
75 | :fail
76 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
77 | rem the _cmd.exe /c_ return code!
78 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
79 | exit /b 1
80 |
81 | :mainEnd
82 | if "%OS%"=="Windows_NT" endlocal
83 |
84 | :omega
85 |
--------------------------------------------------------------------------------
/html/README.md:
--------------------------------------------------------------------------------
1 | Rendering Rich Text Into HTML
2 | ===================================
3 |
4 | For retrieving html output from a given rich text field this rendering libaray includes a snapshot release of the
5 | Contentful Delivery SDK for Java.
6 |
7 | Adding dependencies
8 | -------------------
9 |
10 | For gradle, adding this to `build.gradle` is needed, to allow base SDK snapshots and rendering SDK
11 | dependencies to be found:
12 |
13 | ```groovy
14 | allprojects {
15 | repositories {
16 | // …
17 | maven { url 'https://jitpack.io' }
18 | }
19 | }
20 | ```
21 |
22 | ```groovy
23 | dependencies {
24 | // …
25 | implementation 'com.github.contentful:contentful.java:v10.5.18'
26 | implementation 'com.github.contentful.rich-text-renderer-java:html:2.2.7'
27 | }
28 | ```
29 |
30 | same can be achieved by adding Maven dependencies like so:
31 |
32 | ```xml
33 |
34 |
35 | jitpack.io
36 | https://jitpack.io
37 |
38 |
39 | ```
40 |
41 | ```xml
42 |
43 | com.github.contentful
44 | contentful.java
45 | v10.5.18
46 |
47 |
48 | com.github.contentful.rich-text-renderer-java
49 | html
50 | 2.2.7
51 |
52 | ```
53 |
54 | Calling Contentful Main SDK
55 | ---------------------------
56 |
57 | Now that the base SDK is in place, the next step is to retrieve (_fetch_) an entry from Contentful,
58 | containing Rich Text Data. Following code snippet does this by using `SPACE_ID`, `TOKEN` and
59 | `ENTRY_ID` as placeholders for the actual content that needs fetching. Code needs to run in a background thread.
60 |
61 | ```java
62 | final CDAClient client = CDAClient.builder()
63 | .setSpace(SPACE_ID)
64 | .setToken(TOKEN)
65 | .build();
66 |
67 | final CDAEntry entry = client
68 | .fetch(CDAEntry.class)
69 | .one(ENTRY_ID);
70 | ```
71 |
72 | With the `entry` at hand, getting the `CDARichDocument`, the base of all Rich Text
73 | nodes in the main SDK, is easy if the field id is known:
74 |
75 | ```java
76 | final CDARichDocument node = entry.getField(FIELD_ID);
77 | ```
78 | If your data is fetched from an external tool (e.g., a JavaScript library), it is possible to create a `CDARichDocument` from plain `JSON`. This is especially useful when working with content that is not directly retrieved through the Contentful Java library. To accomplish this, the following steps can be followed using the `GSON` library for `JSON` processing:
79 |
80 | ```java
81 | private final Gson gson = new Gson();
82 | Type type = new TypeToken>(){}.getType();
83 | Map jsonMap = gson.fromJson(json, type);
84 | final CDARichDocument node = RichTextFactory.resolveRichNode(jsonMap);
85 | ```
86 |
87 |
88 | The last step includes the conversion of the rich text node to an html string:
89 |
90 | ```java
91 | final HtmlProcessor processor = new HtmlProcessor();
92 | final HtmlContext context = new HtmlContext();
93 | final String html = processor.process(context, node);
94 | ```
95 |
96 | The `html` variable now contains the html representation of the node.
97 |
98 | Adding Custom Renderers
99 | -----------------------
100 |
101 | To change the output, adding of a new renderer or overriding one is needed.
102 | The `.addRenderer(…,…)` method exists to add a new renderer, and `.overrideRenderer(…,…)` to override an existing renderer. The
103 | Processor contains a list of renderers, which is iterated upon to find one matching the current
104 | Node. For matching a renderer to a node, a `Checker` needs to be provided when a `Renderer` gets added to the `Processor`.
105 |
106 | ```java
107 | processor.addRenderer(
108 | (context, node) -> true, // Checker: Does the renderer need to be invoked?
109 | (context, node) -> node.toString() // Renderer, rendering specific node.
110 | )
111 | ```
112 |
113 | The now added renderer will be working as a fallback. Since it got added last (by using `.addRenderer(…,…)` instead of
114 | `.overrideRenderer(…,…)`) it will get called last in the search of a renderer. It's checker is
115 | setup to always return true, so this being the last, the renderer will always get called. The
116 | renderer in the above example is simply returning the `.toString()` output of the given node.
117 |
118 | A more sorrow check of the type of the node for the `Checker` and a better rendering of the error
119 | is advised, since those presented here are just for demonstration purposes and don't do null
120 | checking or more elaborated transformation of nodes.
121 |
122 | Overriding Default Renderers
123 | ----------------------------
124 |
125 | The example above will not work to override a default renderer, the to-be-overridden renderer will be checked before
126 | the new one. For those kind of challenges, use the `.overrideRenderer(…,…)` method: It will move the renderer
127 | and checker to the front of the list of renderer and will therefore be checked first. If the checker does not return
128 | true, the default renderer will be used. Upon returning the checker returning true, the current search for a
129 | renderer will be aborted and the found renderer be used.
130 |
131 | For inspiration on how custom renderer might look like,
132 | [a look at the source of the default renderer](src/main/java/com/contentful/rich/html/renderer)
133 | is recommended.
134 |
--------------------------------------------------------------------------------
/html/build.gradle:
--------------------------------------------------------------------------------
1 | plugins {
2 | id('java-library')
3 | id('maven-publish')
4 | }
5 |
6 |
7 | jar {
8 | from project.sourceSets.main.allSource
9 | }
10 |
11 | task sourcesJar(type: Jar, dependsOn: classes) {
12 | archiveClassifier = 'sources'
13 | from sourceSets.main.allSource
14 | }
15 |
16 | artifacts {
17 | archives sourcesJar
18 | archives jar
19 | }
20 |
21 |
22 | publishing {
23 | publications {
24 | mavenJava(MavenPublication) {
25 | groupId = 'com.github.contentful.rich'
26 | artifactId = 'html'
27 | version = '1.2.0'
28 | from components.java
29 | artifact(sourcesJar)
30 | }
31 | }
32 | }
33 | repositories {
34 | mavenCentral()
35 | maven { url 'https://jitpack.io' }
36 | }
37 |
38 | dependencies {
39 | api (project(":core"))
40 | api "com.contentful.java:java-sdk:${project.contentful_version}"
41 | implementation 'com.google.code.findbugs:jsr305:3.0.2'
42 | implementation 'org.apache.commons:commons-text:1.10.0'
43 | testImplementation 'com.google.truth:truth:0.42'
44 | testImplementation 'junit:junit:4.13.2'
45 | }
46 | java {
47 | sourceCompatibility = JavaVersion.VERSION_1_8
48 | targetCompatibility = JavaVersion.VERSION_1_8
49 | }
--------------------------------------------------------------------------------
/html/out/production/classes/META-INF/html_main.kotlin_module:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/html/src/main/java/com/contentful/rich/html/HtmlContext.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.html;
2 |
3 | import com.contentful.java.cda.rich.CDARichBlock;
4 | import com.contentful.java.cda.rich.CDARichNode;
5 | import com.contentful.rich.core.Context;
6 |
7 | import java.util.ArrayList;
8 | import java.util.List;
9 |
10 | import javax.annotation.Nonnull;
11 |
12 | /**
13 | * The HTML Context: saving all html nodes up to the root.
14 | */
15 | public class HtmlContext extends Context> {
16 | private final List path = new ArrayList<>();
17 | final String indentation;
18 |
19 | /**
20 | * Create a default context with indentation of two spaces.
21 | */
22 | public HtmlContext() {
23 | this(" ");
24 | }
25 |
26 | /**
27 | * Create a context using the given string as indentation for siblings.
28 | *
29 | * @param indentation a string used for indentation. Use spaces only.
30 | */
31 | public HtmlContext(String indentation) {
32 | this.indentation = indentation;
33 | }
34 |
35 | /**
36 | * Returns the indentation used for one level.
37 | */
38 | public String getIndentation() {
39 | return indentation;
40 | }
41 |
42 | /**
43 | * Called by the infrastructure once a paragraph is entered.
44 | *
45 | * @param paragraph the paragraph node entered
46 | */
47 | @Override public void onBlockEntered(@Nonnull CDARichBlock paragraph) {
48 | path.add(paragraph);
49 | }
50 |
51 | /**
52 | * This method gets called by the infrastructure once a parent node was exited.
53 | *
54 | * @param block the paragraph node exited
55 | */
56 | @Override public void onBlockExited(@Nonnull CDARichBlock block) {
57 | path.remove(path.size() - 1);
58 | }
59 |
60 | /**
61 | * @return the path up to the root element.
62 | */
63 | @Override @Nonnull public List getPath() {
64 | return path;
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/html/src/main/java/com/contentful/rich/html/HtmlProcessor.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.html;
2 |
3 | import com.contentful.rich.core.Processor;
4 |
5 | /**
6 | * Main processor for processing all HTML renderer content. Contains default renderer.
7 | */
8 | public class HtmlProcessor extends Processor {
9 | /**
10 | * Construct the processor, including all html renderer.
11 | */
12 | public HtmlProcessor() {
13 | super();
14 |
15 | new HtmlRendererProvider().provide(this);
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/html/src/main/java/com/contentful/rich/html/HtmlRendererProvider.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.html;
2 |
3 | import com.contentful.java.cda.rich.CDARichDocument;
4 | import com.contentful.java.cda.rich.CDARichHeading;
5 | import com.contentful.java.cda.rich.CDARichHorizontalRule;
6 | import com.contentful.java.cda.rich.CDARichHyperLink;
7 | import com.contentful.java.cda.rich.CDARichListItem;
8 | import com.contentful.java.cda.rich.CDARichNode;
9 | import com.contentful.java.cda.rich.CDARichOrderedList;
10 | import com.contentful.java.cda.rich.CDARichParagraph;
11 | import com.contentful.java.cda.rich.CDARichQuote;
12 | import com.contentful.java.cda.rich.CDARichTable;
13 | import com.contentful.java.cda.rich.CDARichTableCell;
14 | import com.contentful.java.cda.rich.CDARichTableHeaderCell;
15 | import com.contentful.java.cda.rich.CDARichTableRow;
16 | import com.contentful.java.cda.rich.CDARichText;
17 | import com.contentful.java.cda.rich.CDARichUnorderedList;
18 | import com.contentful.rich.core.Processor;
19 | import com.contentful.rich.core.RenderabilityChecker;
20 | import com.contentful.rich.core.Renderer;
21 | import com.contentful.rich.html.renderer.DynamicTagRenderer;
22 | import com.contentful.rich.html.renderer.TagRenderer;
23 | import com.contentful.rich.html.renderer.TagWithArgumentsRenderer;
24 | import com.contentful.rich.html.renderer.TextRenderer;
25 |
26 | import javax.annotation.Nonnull;
27 | import java.util.Map;
28 |
29 | import static com.contentful.rich.html.renderer.TagWithArgumentsRenderer.mapifyArguments;
30 |
31 | /**
32 | * This provider of renderer will provide all available default renderer for creating html output
33 | * from rich text.
34 | *
35 | * @see Processor#addRenderer(RenderabilityChecker, Renderer)
36 | * @see Processor#process(com.contentful.rich.core.Context, CDARichNode)
37 | */
38 | class HtmlRendererProvider {
39 |
40 | /**
41 | * Call this method with a processor to add all default html renderer.
42 | *
43 | * @param processor the processor to be filled up with renderer.
44 | */
45 | void provide(@Nonnull Processor processor) {
46 | processor.addRenderer(
47 | (context, node) -> node instanceof CDARichText,
48 | new TextRenderer()
49 | );
50 | processor.addRenderer((context, node) -> node instanceof CDARichHorizontalRule,
51 | (context, node) -> "
");
52 | processor.addRenderer(
53 | (context, node) -> node instanceof CDARichDocument,
54 | new TagRenderer(processor, "div")
55 | );
56 | processor.addRenderer(
57 | (context, node) -> node instanceof CDARichHyperLink && ((CDARichHyperLink) node).getData() instanceof String,
58 | new TagWithArgumentsRenderer(
59 | processor,
60 | "a",
61 | (node) -> mapifyArguments("href", (String) ((CDARichHyperLink) node).getData()))
62 | );
63 | processor.addRenderer(
64 | (context, node) -> node instanceof CDARichHyperLink && ((CDARichHyperLink) node).getData() instanceof Map,
65 | new TagWithArgumentsRenderer(
66 | processor,
67 | "a",
68 | (node) -> mapifyArguments("href", (String) ((Map) ((CDARichHyperLink) node).getData()).get("uri")))
69 | );
70 | processor.addRenderer(
71 | (context, node) -> node instanceof CDARichQuote,
72 | new TagRenderer(processor, "blockquote")
73 | );
74 | processor.addRenderer(
75 | (context, node) ->
76 | node instanceof CDARichHeading
77 | && ((CDARichHeading) node).getLevel() >= 1
78 | && ((CDARichHeading) node).getLevel() <= 6,
79 | new DynamicTagRenderer(processor, (node -> "h" + ((CDARichHeading) node).getLevel()))
80 | );
81 | processor.addRenderer(
82 | (context, node) -> node instanceof CDARichOrderedList,
83 | new TagRenderer(processor, "ol")
84 | );
85 | processor.addRenderer(
86 | (context, node) -> node instanceof CDARichListItem,
87 | new TagRenderer(processor, "li")
88 | );
89 | processor.addRenderer(
90 | (context, node) -> node instanceof CDARichUnorderedList,
91 | new TagRenderer(processor, "ul")
92 | );
93 | processor.addRenderer(
94 | (context, node) -> node instanceof CDARichTable,
95 | new TagRenderer(processor, "table")
96 | );
97 | processor.addRenderer(
98 | (context, node) -> node instanceof CDARichTableHeaderCell,
99 | new TagRenderer(processor, "th")
100 | );
101 | processor.addRenderer(
102 | (context, node) -> node instanceof CDARichTableRow,
103 | new TagRenderer(processor, "tr")
104 | );
105 | processor.addRenderer(
106 | (context, node) -> node instanceof CDARichTableCell,
107 | new TagRenderer(processor, "td")
108 | );
109 | // needs to be last but one
110 | processor.addRenderer(
111 | (context, node) -> node instanceof CDARichParagraph,
112 | new TagRenderer(processor, "p")
113 | );
114 | }
115 | }
116 |
--------------------------------------------------------------------------------
/html/src/main/java/com/contentful/rich/html/renderer/DynamicTagRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.html.renderer;
2 |
3 | import com.contentful.java.cda.rich.CDARichNode;
4 | import com.contentful.rich.core.Processor;
5 | import com.contentful.rich.html.HtmlContext;
6 |
7 | import javax.annotation.Nonnull;
8 |
9 | /**
10 | * This renderer updates it's tag based on the incoming node.
11 | */
12 | public class DynamicTagRenderer extends TagRenderer {
13 | private final TagNameProvider provider;
14 |
15 | /**
16 | * Constructs a new tag renderer
17 | *
18 | * @param processor the processor containing all renderer
19 | * @param provider a provider for dynamic tag names
20 | */
21 | public DynamicTagRenderer(Processor processor, TagNameProvider provider) {
22 | super(processor, null);
23 | this.provider = provider;
24 | }
25 |
26 | @Nonnull @Override protected String startTag(@Nonnull CDARichNode node) {
27 | return "<" + provider.getTag(node) + ">";
28 | }
29 |
30 | @Nonnull @Override protected String endTag(@Nonnull CDARichNode node) {
31 | return "";
32 | }
33 |
34 | public interface TagNameProvider {
35 | @Nonnull
36 | String getTag(@Nonnull CDARichNode node);
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/html/src/main/java/com/contentful/rich/html/renderer/TagRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.html.renderer;
2 |
3 | import com.contentful.java.cda.rich.CDARichBlock;
4 | import com.contentful.java.cda.rich.CDARichHyperLink;
5 | import com.contentful.java.cda.rich.CDARichNode;
6 | import com.contentful.rich.core.Processor;
7 | import com.contentful.rich.core.Renderer;
8 | import com.contentful.rich.html.HtmlContext;
9 |
10 | import javax.annotation.Nonnull;
11 | import javax.annotation.Nullable;
12 | import java.util.stream.Collectors;
13 |
14 | import static java.lang.String.format;
15 | import static java.util.Locale.getDefault;
16 |
17 | /**
18 | * This renderer will generate an html tag.
19 | */
20 | public class TagRenderer implements Renderer {
21 | private final Processor processor;
22 | String tag;
23 |
24 | /**
25 | * Constructs a new tag renderer
26 | *
27 | * @param processor the processor containing all renderer
28 | * @param tag the tag to be enclosing the content.
29 | */
30 | public TagRenderer(Processor processor, String tag) {
31 | this.processor = processor;
32 | this.tag = tag;
33 | }
34 |
35 | /**
36 | * Takes the given node and returns its html representation.
37 | *
38 | * @param context the generic context this node should be rendered in.
39 | * @param node the node to be rendered.
40 | * @return a string containing the elements, if a non {@see CDARichParagraph} is
41 | * encountered only the opening and closing tags will be returned.
42 | */
43 | @Nullable @Override
44 | public String render(@Nonnull HtmlContext context, @Nonnull CDARichNode node) {
45 | final StringBuilder result = new StringBuilder(startTag(node));
46 |
47 | if (node instanceof CDARichBlock) {
48 | for (final CDARichNode item : ((CDARichBlock) node).getContent()) {
49 | String itemResult = processor.process(context, item);
50 | if (itemResult != null) {
51 | result.append(itemResult);
52 | } else { // none found
53 | appendErrorNode(context, result, item);
54 | }
55 | }
56 | }
57 |
58 | return result.append(endTag(node)).toString();
59 | }
60 |
61 | private void appendErrorNode(@Nonnull HtmlContext context, StringBuilder result, CDARichNode item) {
62 | result
63 | .append(context.getIndentation())
64 | .append("");
72 | }
73 |
74 | private String createNodeName(CDARichNode node) {
75 | if (node instanceof CDARichHyperLink && ((CDARichHyperLink) node).getData() != null) {
76 | final CDARichHyperLink link = (CDARichHyperLink) node;
77 | return format(
78 | getDefault(),
79 | "%s<%s>",
80 | link.getClass().getSimpleName(),
81 | link.getData().getClass().getSimpleName());
82 | } else {
83 | return node.getClass().getSimpleName();
84 | }
85 | }
86 |
87 | private int getIndexInParent(@Nonnull HtmlContext context, CDARichNode x) {
88 | final int currentIndex = context.getPath().indexOf(x);
89 | if (currentIndex > 0) {
90 | return ((CDARichBlock) context.getPath().get(currentIndex - 1)).getContent().indexOf(x);
91 | } else {
92 | return 0;
93 | }
94 | }
95 |
96 | /**
97 | * Override this method if you want something special to be returned once the tag is openened.
98 | *
99 | * @param node the node used.
100 | * @return the tag setup.
101 | * @see TagWithArgumentsRenderer#startTag(CDARichNode)
102 | */
103 | @Nonnull
104 | protected String startTag(@Nonnull CDARichNode node) {
105 | return "<" + tag + ">";
106 | }
107 |
108 | /**
109 | * Return a string closing this tag.
110 | *
111 | * @param node the node to be rendered
112 | * @return a string closing this tag.
113 | */
114 | @Nonnull
115 | protected String endTag(@Nonnull CDARichNode node) {
116 | if(tag.equals("a")) {
117 | return "";
118 | } else {
119 | return "";
120 | }
121 |
122 | }
123 | }
124 |
--------------------------------------------------------------------------------
/html/src/main/java/com/contentful/rich/html/renderer/TagWithArgumentsRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.html.renderer;
2 |
3 | import com.contentful.java.cda.rich.CDARichNode;
4 | import com.contentful.rich.core.Processor;
5 | import com.contentful.rich.html.HtmlContext;
6 |
7 | import javax.annotation.Nonnull;
8 | import java.util.HashMap;
9 | import java.util.Map;
10 |
11 | /**
12 | * Adds arguments to a tag when rendering a Rich Text.
13 | */
14 | public class TagWithArgumentsRenderer extends TagRenderer {
15 | private final ArgumentsProvider provider;
16 |
17 | @Nonnull
18 | public static Map mapifyArguments(@Nonnull String... args) {
19 | final HashMap result = new HashMap<>(args.length / 2);
20 | for (int i = 0; i < args.length; i += 2) {
21 | final String key = args[i];
22 | final String value = args[i + 1];
23 | result.put(key, value);
24 | }
25 | return result;
26 | }
27 |
28 | /**
29 | * Create a tag renderer.
30 | *
31 | * @param processor the processor containing all renderers.
32 | * @param tag the tag to be rendered.
33 | * @param provider the provider of arguments.
34 | */
35 | public TagWithArgumentsRenderer(Processor processor, String tag, ArgumentsProvider provider) {
36 | super(processor, tag);
37 | this.provider = provider;
38 | }
39 |
40 | /**
41 | * Overridden to enable arguments parsing.
42 | *
43 | * @param node the node to be used by the provider to get the arguments.
44 | * @return a html tag including arguments.
45 | */
46 | @Nonnull @Override
47 | protected String startTag(@Nonnull CDARichNode node) {
48 | return "<" + tag + " " + stringifyArgumentMap(provider.provide(node)) + ">";
49 | }
50 |
51 | String stringifyArgumentMap(Map arguments) {
52 | final StringBuilder builder = new StringBuilder();
53 | for (final String key : arguments.keySet()) {
54 | builder.append(key).append("=").append('"').append(arguments.get(key)).append('"');
55 | }
56 | return builder.toString();
57 | }
58 |
59 | /**
60 | * Create arguments from a node.
61 | */
62 | public interface ArgumentsProvider {
63 | Map provide(CDARichNode node);
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/html/src/main/java/com/contentful/rich/html/renderer/TextRenderer.java:
--------------------------------------------------------------------------------
1 | package com.contentful.rich.html.renderer;
2 |
3 | import com.contentful.java.cda.rich.CDARichMark;
4 | import com.contentful.java.cda.rich.CDARichNode;
5 | import com.contentful.java.cda.rich.CDARichText;
6 | import com.contentful.rich.core.Renderer;
7 | import com.contentful.rich.html.HtmlContext;
8 |
9 | import org.apache.commons.text.StringEscapeUtils;
10 |
11 | import javax.annotation.Nonnull;
12 | import javax.annotation.Nullable;
13 |
14 | /**
15 | * This class will take a {@see CDARichText} node and process a html representation of it.
16 | */
17 | public class TextRenderer implements Renderer {
18 | /**
19 | * Transforms (renders) a {@see CDARichNode} as a string.
20 | *
21 | * @param context the generic context this node should be rendered in.
22 | * @param node the node to be rendered.
23 | * @return the text represented by the text node or null if no text node is given.
24 | */
25 | @Nullable @Override
26 | public String render(@Nonnull HtmlContext context, @Nonnull CDARichNode node) {
27 | final CharSequence text = ((CDARichText) node).getText();
28 | final CharSequence escapedText = StringEscapeUtils.escapeHtml4(text.toString());
29 | final StringBuilder result = new StringBuilder(escapedText);
30 | for (final CDARichMark mark : ((CDARichText) node).getMarks()) {
31 |
32 | if (mark instanceof CDARichMark.CDARichMarkUnderline) {
33 | result.insert(0, "").append("");
34 | }
35 | if (mark instanceof CDARichMark.CDARichMarkBold) {
36 | result.insert(0, "").append("");
37 | }
38 | if (mark instanceof CDARichMark.CDARichMarkItalic) {
39 | result.insert(0, "").append("");
40 | }
41 | if (mark instanceof CDARichMark.CDARichMarkSuperscript) {
42 | result.insert(0, "").append("");
43 | }
44 | if (mark instanceof CDARichMark.CDARichMarkSubscript) {
45 | result.insert(0, "").append("");
46 | }
47 | if (mark instanceof CDARichMark.CDARichMarkCode) {
48 | result.insert(0, "").append("");
49 | }
50 | if (mark instanceof CDARichMark.CDARichMarkCustom) {
51 | final String tag = ((CDARichMark.CDARichMarkCustom) mark).getType();
52 | result.insert(0, ">").insert(0, tag).insert(0, "<").append("");
53 | }
54 | }
55 |
56 | return result.toString();
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/html/src/test/java/AllTheThingsTest.java:
--------------------------------------------------------------------------------
1 | import com.contentful.java.cda.rich.CDARichDocument;
2 | import com.contentful.java.cda.rich.CDARichHeading;
3 | import com.contentful.java.cda.rich.CDARichHorizontalRule;
4 | import com.contentful.java.cda.rich.CDARichHyperLink;
5 | import com.contentful.java.cda.rich.CDARichListItem;
6 | import com.contentful.java.cda.rich.CDARichMark;
7 | import com.contentful.java.cda.rich.CDARichNode;
8 | import com.contentful.java.cda.rich.CDARichOrderedList;
9 | import com.contentful.java.cda.rich.CDARichParagraph;
10 | import com.contentful.java.cda.rich.CDARichQuote;
11 | import com.contentful.java.cda.rich.CDARichText;
12 | import com.contentful.java.cda.rich.CDARichUnorderedList;
13 | import com.contentful.rich.html.HtmlContext;
14 | import com.contentful.rich.html.HtmlProcessor;
15 |
16 | import org.junit.Test;
17 |
18 | import java.util.ArrayList;
19 |
20 | import static com.google.common.collect.Lists.newArrayList;
21 | import static com.google.common.truth.Truth.assertThat;
22 |
23 | public class AllTheThingsTest {
24 | @Test
25 | public void allTheNodes() {
26 | final HtmlProcessor processor = new HtmlProcessor();
27 |
28 | final String result = processor.process(new HtmlContext(), createAllNode());
29 |
30 | assertThat(result).isEqualTo(""+
31 | "
"+
32 | "heading - 1"+
33 | "
"+
34 | "
"+
35 | "heading - 2"+
36 | "
"+
37 | "
"+
38 | "heading - 3"+
39 | "
"+
40 | "
"+
41 | "heading - 4"+
42 | "
"+
43 | "
"+
44 | "heading - 5"+
45 | "
"+
46 | "
"+
47 | "heading - 6"+
48 | "
"+
49 | "
"+
50 | "
"+
51 | "Hyper hyper"+
52 | ""+
53 | "
ALL THE TEXT MARKS!"+
54 | "
"+
55 | "- "+
56 | "some list item content"+
57 | "
"+
58 | "- "+
59 | "some list item content"+
60 | "
"+
61 | "- "+
62 | "some list item content"+
63 | "
"+
64 | "
"+
65 | "
"+
66 | "- "+
67 | "some list item content"+
68 | "
"+
69 | "- "+
70 | "some list item content"+
71 | "
"+
72 | "- "+
73 | "some list item content"+
74 | "
"+
75 | "- "+
76 | "some list item content"+
77 | "
"+
78 | "
"+
79 | "
"+
80 | "Paragraph"+
81 | "
"+
82 | "
"+
83 | "Famous quote"+
84 | "
"+
85 | "
", new ArrayList<>());
20 | final String result = processor.process(context, text);
21 |
22 | assertThat(result).isEqualTo("Some rich text with html tags<br/>");
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/html/src/test/java/HeadingTest.java:
--------------------------------------------------------------------------------
1 | import com.contentful.java.cda.rich.CDARichHeading;
2 | import com.contentful.rich.html.HtmlContext;
3 | import com.contentful.rich.html.HtmlProcessor;
4 |
5 | import org.junit.Test;
6 |
7 | import static com.google.common.truth.Truth.assertThat;
8 |
9 | public class HeadingTest {
10 | @Test
11 | public void canCreateAllHeadings() {
12 | final HtmlProcessor processor = new HtmlProcessor();
13 | final HtmlContext context = new HtmlContext();
14 |
15 | assertThat(processor.process(context, new CDARichHeading(1))).isEqualTo("");
16 | assertThat(processor.process(context, new CDARichHeading(2))).isEqualTo("");
17 | assertThat(processor.process(context, new CDARichHeading(3))).isEqualTo("");
18 | assertThat(processor.process(context, new CDARichHeading(4))).isEqualTo("");
19 | assertThat(processor.process(context, new CDARichHeading(5))).isEqualTo("");
20 | assertThat(processor.process(context, new CDARichHeading(6))).isEqualTo("");
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/html/src/test/java/LinksTest.java:
--------------------------------------------------------------------------------
1 | import com.contentful.java.cda.rich.CDARichHyperLink;
2 | import com.contentful.java.cda.rich.CDARichText;
3 | import com.contentful.rich.html.HtmlContext;
4 | import com.contentful.rich.html.HtmlProcessor;
5 |
6 | import org.junit.Test;
7 |
8 | import java.util.ArrayList;
9 | import java.util.HashMap;
10 | import java.util.Map;
11 |
12 | import static com.google.common.truth.Truth.assertThat;
13 |
14 | public class LinksTest {
15 |
16 | @Test
17 | public void renderLinkTest() {
18 | final HtmlProcessor processor = new HtmlProcessor();
19 | final HtmlContext context = new HtmlContext();
20 |
21 |
22 | final CDARichHyperLink link = new CDARichHyperLink("https://contentful.com");
23 | link.getContent().add(new CDARichText("Some link text
", new ArrayList<>()));
24 |
25 | final String result = processor.process(context, link);
26 |
27 | assertThat(result).isEqualTo("" +
28 | "" +
29 | "Some link text<br/>" +
30 | "");
31 | }
32 |
33 | @Test
34 | public void renderLinkWithUriTest() {
35 | final HtmlProcessor processor = new HtmlProcessor();
36 | final HtmlContext context = new HtmlContext();
37 |
38 | final Map linkProps = new HashMap<>();
39 | linkProps.put("uri", "https://contentful.com");
40 | final CDARichHyperLink link = new CDARichHyperLink(linkProps);
41 | link.getContent().add(new CDARichText("Some link text
", new ArrayList<>()));
42 |
43 | final String result = processor.process(context, link);
44 |
45 | assertThat(result).isEqualTo("" +
46 | "" +
47 | "Some link text<br/>" +
48 | "");
49 | }
50 |
51 | @Test
52 | public void createUnsanitzedStrings() {
53 | final HtmlProcessor processor = new HtmlProcessor();
54 | final HtmlContext context = new HtmlContext();
55 |
56 | final CDARichHyperLink link = new CDARichHyperLink("https://contentful.com");
57 | link.getContent().add(new CDARichText("Some link text", new ArrayList<>()));
58 |
59 | final String result = processor.process(context, link);
60 |
61 | assertThat(result).isEqualTo("" +
62 | "" +
63 | "Some link text</a>" +
64 | "");
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/html/src/test/java/ListsTest.java:
--------------------------------------------------------------------------------
1 | import com.contentful.java.cda.rich.CDARichListItem;
2 | import com.contentful.java.cda.rich.CDARichMark;
3 | import com.contentful.java.cda.rich.CDARichOrderedList;
4 | import com.contentful.java.cda.rich.CDARichParagraph;
5 | import com.contentful.java.cda.rich.CDARichText;
6 | import com.contentful.java.cda.rich.CDARichUnorderedList;
7 | import com.contentful.rich.html.HtmlContext;
8 | import com.contentful.rich.html.HtmlProcessor;
9 |
10 | import org.junit.Test;
11 |
12 | import java.util.ArrayList;
13 | import java.util.List;
14 |
15 | import static com.google.common.truth.Truth.assertThat;
16 |
17 | public class ListsTest {
18 | @Test
19 | public void threeUnorderedElementsListTest() {
20 | final HtmlProcessor processor = new HtmlProcessor();
21 | final HtmlContext context = new HtmlContext();
22 |
23 | final CDARichUnorderedList list = new CDARichUnorderedList();
24 | list.getContent().add(textListItem("one"));
25 | list.getContent().add(textListItem("two"));
26 | list.getContent().add(textListItem("three"));
27 |
28 | final String result = processor.process(context, list);
29 |
30 | assertThat(result).isEqualTo(
31 | ""+
32 | "- "+
33 | "
"+
34 | "one"+
35 | "
"+
36 | " "+
37 | "- "+
38 | "
"+
39 | "two"+
40 | "
"+
41 | " "+
42 | "- "+
43 | "
"+
44 | "three"+
45 | "
"+
46 | " "+
47 | "
");
48 | }
49 |
50 | @Test
51 | public void threeUnorderedElementsListAndOneNestedOrdered() {
52 | final HtmlProcessor processor = new HtmlProcessor();
53 | final HtmlContext context = new HtmlContext();
54 |
55 | final CDARichOrderedList orderedList = new CDARichOrderedList();
56 | orderedList.getContent().add(textListItem("a"));
57 | orderedList.getContent().add(textListItem("b"));
58 | orderedList.getContent().add(textListItem("c"));
59 |
60 | final CDARichListItem orderedListListItem = new CDARichListItem();
61 | orderedListListItem.getContent().add(orderedList);
62 |
63 | final CDARichUnorderedList unorderedList = new CDARichUnorderedList();
64 | unorderedList.getContent().add(textListItem("one"));
65 | unorderedList.getContent().add(textListItem("two"));
66 | unorderedList.getContent().add(textListItem("three"));
67 | unorderedList.getContent().add(orderedListListItem);
68 | unorderedList.getContent().add(beautifyTextItem("four"));
69 |
70 | final String result = processor.process(context, unorderedList);
71 |
72 | assertThat(result).isEqualTo("");
113 | }
114 |
115 | private CDARichListItem textListItem(String text) {
116 | final CDARichParagraph paragraph = new CDARichParagraph();
117 | paragraph.getContent().add(new CDARichText(text, new ArrayList<>()));
118 | final CDARichListItem item = new CDARichListItem();
119 | item.getContent().add(paragraph);
120 | return item;
121 | }
122 |
123 | private CDARichListItem beautifyTextItem(String text) {
124 | final CDARichParagraph paragraph = new CDARichParagraph();
125 | final List allTheMarks = new ArrayList<>();
126 | allTheMarks.add(new CDARichMark.CDARichMarkUnderline());
127 | allTheMarks.add(new CDARichMark.CDARichMarkBold());
128 | allTheMarks.add(new CDARichMark.CDARichMarkItalic());
129 | allTheMarks.add(new CDARichMark.CDARichMarkCode());
130 | allTheMarks.add(new CDARichMark.CDARichMarkCustom("\uD83D\uDC51"));
131 | paragraph.getContent().add(new CDARichText(text, allTheMarks));
132 | final CDARichListItem item = new CDARichListItem();
133 | item.getContent().add(paragraph);
134 | return item;
135 | }
136 | }
137 |
--------------------------------------------------------------------------------
/html/src/test/java/MarksTextTest.java:
--------------------------------------------------------------------------------
1 | import com.contentful.java.cda.rich.CDARichMark;
2 | import com.contentful.java.cda.rich.CDARichText;
3 | import com.contentful.rich.html.HtmlContext;
4 | import com.contentful.rich.html.HtmlProcessor;
5 |
6 | import org.junit.Test;
7 |
8 | import java.util.ArrayList;
9 | import java.util.List;
10 |
11 | import static com.google.common.truth.Truth.assertThat;
12 |
13 | public class MarksTextTest {
14 |
15 | @Test
16 | public void noMarksTest() {
17 | final HtmlProcessor processor = new HtmlProcessor();
18 | final HtmlContext context = new HtmlContext();
19 |
20 | final String result = processor.process(context, new CDARichText("text", new ArrayList<>()));
21 |
22 | assertThat(result).isEqualTo("text");
23 | }
24 |
25 | @Test
26 | public void boldTextTest() {
27 | final HtmlProcessor processor = new HtmlProcessor();
28 | final HtmlContext context = new HtmlContext();
29 |
30 | final List markers = new ArrayList<>();
31 | markers.add(new CDARichMark.CDARichMarkBold());
32 |
33 | final String result = processor.process(context, new CDARichText("BoldText", markers));
34 |
35 | assertThat(result).isEqualTo("BoldText");
36 | }
37 |
38 | @Test
39 | public void underlineTextTest() {
40 | final HtmlProcessor processor = new HtmlProcessor();
41 | final HtmlContext context = new HtmlContext();
42 |
43 | final List markers = new ArrayList<>();
44 | markers.add(new CDARichMark.CDARichMarkUnderline());
45 |
46 | final String result = processor.process(context, new CDARichText("Underlined", markers));
47 |
48 | assertThat(result).isEqualTo("Underlined");
49 | }
50 |
51 | @Test
52 | public void testItalicHtml() {
53 | final HtmlProcessor processor = new HtmlProcessor();
54 | final HtmlContext context = new HtmlContext();
55 |
56 | final List markers = new ArrayList<>();
57 | markers.add(new CDARichMark.CDARichMarkItalic());
58 |
59 | final String result = processor.process(context, new CDARichText("Italic", markers));
60 |
61 | assertThat(result).isEqualTo("Italic");
62 | }
63 |
64 | @Test
65 | public void codeTextTest() {
66 | final HtmlProcessor processor = new HtmlProcessor();
67 | final HtmlContext context = new HtmlContext();
68 |
69 | final List markers = new ArrayList<>();
70 | markers.add(new CDARichMark.CDARichMarkCode());
71 |
72 | final String result = processor.process(context, new CDARichText("final String code;", markers));
73 |
74 | assertThat(result).isEqualTo("final String code;");
75 | }
76 |
77 | @Test
78 | public void customTextTest() {
79 | final HtmlProcessor processor = new HtmlProcessor();
80 | final HtmlContext context = new HtmlContext();
81 |
82 | final List markers = new ArrayList<>();
83 | markers.add(new CDARichMark.CDARichMarkCustom("🧀"));
84 |
85 | final String result = processor.process(context, new CDARichText("🐭", markers));
86 |
87 | assertThat(result).isEqualTo("<🧀>🐭");
88 | }
89 |
90 | @Test
91 | public void allTextTest() {
92 | final HtmlProcessor processor = new HtmlProcessor();
93 | final HtmlContext context = new HtmlContext();
94 |
95 | final List markers = new ArrayList<>();
96 | markers.add(new CDARichMark.CDARichMarkCustom("custom"));
97 | markers.add(new CDARichMark.CDARichMarkItalic());
98 | markers.add(new CDARichMark.CDARichMarkBold());
99 | markers.add(new CDARichMark.CDARichMarkCode());
100 | markers.add(new CDARichMark.CDARichMarkUnderline());
101 | markers.add(new CDARichMark.CDARichMarkCustom("span"));
102 |
103 | final String result = processor.process(context, new CDARichText("All in all", markers));
104 |
105 | assertThat(result).isEqualTo("All in all");
106 | }
107 | }
108 |
--------------------------------------------------------------------------------
/html/src/test/java/lib/ContentfulCreator.java:
--------------------------------------------------------------------------------
1 | package lib;
2 |
3 | import com.contentful.java.cda.CDAEntry;
4 | import com.contentful.java.cda.CDAResource;
5 |
6 | import java.lang.reflect.Field;
7 |
8 | import static com.google.common.collect.Maps.newHashMap;
9 |
10 | public class ContentfulCreator {
11 | public static CDAResource mockCDAEntry() {
12 | final CDAEntry entry = new CDAEntry();
13 | Field attrs = null;
14 | for (final Field field : CDAResource.class.getDeclaredFields()) {
15 | if ("attrs".equals(field.getName())) {
16 | attrs = field;
17 | }
18 | }
19 | if (attrs != null) {
20 | attrs.setAccessible(true);
21 | try {
22 | attrs.set(entry, newHashMap());
23 | } catch (IllegalAccessException e) {
24 | }
25 | attrs.setAccessible(false);
26 | }
27 |
28 | entry.attrs().put("id", "fake_id");
29 | entry.attrs().put("contentType", "fake_type");
30 | return entry;
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/jitpack.yml:
--------------------------------------------------------------------------------
1 | jdk:
2 | - openjdk11
--------------------------------------------------------------------------------
/settings.gradle.kts:
--------------------------------------------------------------------------------
1 | pluginManagement {
2 | repositories {
3 | gradlePluginPortal()
4 | mavenCentral()
5 | google()
6 | }
7 | resolutionStrategy {
8 | eachPlugin {
9 | if (requested.id.id.startsWith("com.android")) {
10 | useModule("com.android.tools.build:gradle:7.4.2")
11 | }
12 | if (requested.id.id.startsWith("org.jetbrains.kotlin")) {
13 | useVersion("1.8.0")
14 | }
15 | }
16 | }
17 | }
18 |
19 | rootProject.name = "rich-text-renderer"
20 |
21 | include ("android")
22 | include ("android_sample")
23 | include ("core")
24 | include ("html")
25 |
26 |
--------------------------------------------------------------------------------