structured_text_renderer 0.0.1

data/spec/lib/structured_text_renderer/block_renderers/paragraph_renderer_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+mock_node = {"content" => [{"value" => "foo", "nodeType" => "text"}]}
+
+mock_node_with_marks = {"content" => [{"value" => "foo", "nodeType" => "text", "marks" => [{"type" => "bold"}]}]}
+
+describe StructuredTextRenderer::ParagraphRenderer do
+  subject do
+    described_class.new(
+      'text' => StructuredTextRenderer::TextRenderer,
+      'bold' => StructuredTextRenderer::BoldRenderer
+    )
+  end
+
+  describe '#render' do
+    it 'renders a p' do
+      expect(subject.render(mock_node)).to eq "<p>foo</p>"
+    end
+
+    it 'will propagate marks to text renderers' do
+      expect(subject.render(mock_node_with_marks)).to eq "<p><b>foo</b></p>"
+    end
+  end
+end

data/spec/lib/structured_text_renderer/block_renderers/quote_renderer_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+mock_node = {"content" => [{"nodeType" => "paragraph", "content" => [{"value" => "foo", "nodeType" => "text"}]}]}
+
+mock_node_with_marks = {"content" => [{"nodeType" => "paragraph", "content" => [{"value" => "foo", "nodeType" => "text", "marks" => [{"type" => "bold"}]}]}]}
+
+describe StructuredTextRenderer::QuoteRenderer do
+  subject do
+    described_class.new(
+      'paragraph' => StructuredTextRenderer::ParagraphRenderer,
+      'text' => StructuredTextRenderer::TextRenderer,
+      'bold' => StructuredTextRenderer::BoldRenderer
+    )
+  end
+
+  describe '#render' do
+    it 'renders a blockqoute' do
+      expect(subject.render(mock_node)).to eq "<blockqoute><p>foo</p></blockqoute>"
+    end
+
+    it 'will propagate marks to text renderers' do
+      expect(subject.render(mock_node_with_marks)).to eq "<blockqoute><p><b>foo</b></p></blockqoute>"
+    end
+  end
+end

data/spec/lib/structured_text_renderer/block_renderers/unordered_list_renderer_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+mock_node = {"content" => [
+  {
+    "content" => [{
+      "content" => [{
+        "value" => "foo",
+        "nodeType" => "text",
+        "nodeClass" => "text"
+      }],
+      "nodeType" => "paragraph",
+      "nodeClass" => "block"
+    }],
+    "nodeType" => "list-item",
+    "nodeClass" => "block"
+  }]
+}
+
+mock_node_with_marks = {"content" => [
+  {
+    "content" => [{
+      "content" => [{
+        "marks" => [{"type" => "bold"}],
+        "value" => "foo",
+        "nodeType" => "text",
+        "nodeClass" => "text"
+      }],
+      "nodeType" => "paragraph",
+      "nodeClass" => "block"
+    }],
+    "nodeType" => "list-item",
+    "nodeClass" => "block"
+  }]
+}
+
+
+describe StructuredTextRenderer::UnorderedListRenderer do
+  subject do
+    described_class.new(
+      'paragraph' => StructuredTextRenderer::ParagraphRenderer,
+      'text' => StructuredTextRenderer::TextRenderer,
+      'bold' => StructuredTextRenderer::BoldRenderer,
+      'list-item' => StructuredTextRenderer::ListItemRenderer
+    )
+  end
+
+  describe '#render' do
+    it 'renders a ul' do
+      expect(subject.render(mock_node)).to eq "<ul><li><p>foo</p></li></ul>"
+    end
+
+    it 'will propagate marks to text renderers' do
+      expect(subject.render(mock_node_with_marks)).to eq "<ul><li><p><b>foo</b></p></li></ul>"
+    end
+  end
+end

data/spec/lib/structured_text_renderer/document_renderers/document_renderer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+mock_document = {
+    "nodeType" => "document",
+    "content" => [
+        {
+            "content" => [{"value" => "foo", "nodeType" => "text", "marks" => [{"type" => "bold"}]}],
+            "nodeType" => "heading-1",
+        }
+    ],
+}
+
+mock_document_with_unknown_nodetype = {
+    "nodeType" => "document",
+    "content" => [
+        {
+            "content" => [{"value" => "foo", "nodeType" => "text", "marks" => [{"type" => "bold"}]}],
+            "nodeType" => "unknown",
+        }
+    ],
+}
+
+describe StructuredTextRenderer::DocumentRenderer do
+  subject do
+    described_class.new(
+      'heading-1' => StructuredTextRenderer::HeadingOneRenderer,
+      'text' => StructuredTextRenderer::TextRenderer,
+      'bold' => StructuredTextRenderer::BoldRenderer,
+      nil => StructuredTextRenderer::NullRenderer
+    )
+  end
+
+  describe '#render' do
+    it 'propagates rendering to renderers' do
+      expect(subject.render(mock_document)).to eq "<h1><b>foo</b></h1>"
+    end
+
+    it 'will raise an error unknown node types' do
+      expect { subject.render(mock_document_with_unknown_nodetype) }.to raise_error "No renderer defined for 'unknown' nodes"
+    end
+  end
+end

data/spec/lib/structured_text_renderer/null_renderer_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe StructuredTextRenderer::NullRenderer do
+  subject { described_class.new }
+
+  describe 'null renderer will raise errors for unknown nodes' do
+    it 'will look for nodeType' do
+      expect { subject.render({'nodeType' => 'foo'}) }.to raise_error "No renderer defined for 'foo' nodes"
+    end
+
+    it 'will look for type' do
+      expect { subject.render({'type' => 'foo'}) }.to raise_error "No renderer defined for 'foo' nodes"
+    end
+
+    it 'if none of the above found, will dump the node' do
+      expect { subject.render({'foo' => 'bar'}) }.to raise_error "No renderer defined for '{\"foo\"=>\"bar\"}' nodes"
+    end
+  end
+end

data/spec/lib/structured_text_renderer/renderer_spec.rb

@@ -0,0 +1,308 @@
+require 'spec_helper'
+
+full_document = {
+    "content" => [
+        {
+            "data" => {},
+            "content" => [
+                {
+                    "marks" => [],
+                    "value" => "Some heading",
+                    "nodeType" => "text",
+                    "nodeClass" => "text",
+                }
+            ],
+            "nodeType" => "heading-1",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {"marks" => [], "value" => "", "nodeType" => "text", "nodeClass" => "text"}
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {
+                "target" => {
+                    "sys" => {
+                        "id" => "49rofLvvxCOiIMIi6mk8ai",
+                        "type" => "Link",
+                        "linkType" => "Entry",
+                    }
+                }
+            },
+            "content" => [
+                {"marks" => [], "value" => "", "nodeType" => "text", "nodeClass" => "text"}
+            ],
+            "nodeType" => "embedded-entry-block",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {
+                    "marks" => [],
+                    "value" => "Some subheading",
+                    "nodeType" => "text",
+                    "nodeClass" => "text",
+                }
+            ],
+            "nodeType" => "heading-2",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {
+                    "marks" => [{"data" => {}, "type" => "bold", "object" => "mark"}],
+                    "value" => "Some bold",
+                    "nodeType" => "text",
+                    "nodeClass" => "text",
+                }
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {
+                    "marks" => [{"data" => {}, "type" => "italic", "object" => "mark"}],
+                    "value" => "Some italics",
+                    "nodeType" => "text",
+                    "nodeClass" => "text",
+                }
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {
+                    "marks" => [{"data" => {}, "type" => "underline", "object" => "mark"}],
+                    "value" => "Some underline",
+                    "nodeType" => "text",
+                    "nodeClass" => "text",
+                }
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {"marks" => [], "value" => "", "nodeType" => "text", "nodeClass" => "text"}
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {"marks" => [], "value" => "", "nodeType" => "text", "nodeClass" => "text"}
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {
+                "target" => {
+                    "sys" => {
+                        "id" => "5ZF9Q4K6iWSYIU2OUs0UaQ",
+                        "type" => "Link",
+                        "linkType" => "Entry",
+                    }
+                }
+            },
+            "content" => [
+                {"marks" => [], "value" => "", "nodeType" => "text", "nodeClass" => "text"}
+            ],
+            "nodeType" => "embedded-entry-block",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {"marks" => [], "value" => "", "nodeType" => "text", "nodeClass" => "text"}
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {
+                    "marks" => [],
+                    "value" => "Some raw content",
+                    "nodeType" => "text",
+                    "nodeClass" => "text",
+                }
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {"marks" => [], "value" => "", "nodeType" => "text", "nodeClass" => "text"}
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {
+                    "marks" => [],
+                    "value" => "An unpublished embed:",
+                    "nodeType" => "text",
+                    "nodeClass" => "text",
+                }
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {"marks" => [], "value" => "", "nodeType" => "text", "nodeClass" => "text"}
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {
+                "target" => {
+                    "sys" => {
+                        "id" => "q2hGXkd5tICym64AcgeKK",
+                        "type" => "Link",
+                        "linkType" => "Entry",
+                    }
+                }
+            },
+            "content" => [
+                {"marks" => [], "value" => "", "nodeType" => "text", "nodeClass" => "text"}
+            ],
+            "nodeType" => "embedded-entry-block",
+            "nodeClass" => "block",
+        },
+        {
+            "data" => {},
+            "content" => [
+                {
+                    "marks" => [],
+                    "value" => "Some more content",
+                    "nodeType" => "text",
+                    "nodeClass" => "text",
+                }
+            ],
+            "nodeType" => "paragraph",
+            "nodeClass" => "block",
+        },
+    ],
+    "nodeType" => "document",
+    "nodeClass" => "document",
+}
+
+describe StructuredTextRenderer::Renderer do
+  subject { described_class.new }
+
+  describe '#render' do
+    it 'by default renders html' do
+      expect(subject.render(full_document)).to eq [
+        "<h1>Some heading</h1>",
+        "<p></p>",
+        '<div>{"target"=>{"sys"=>{"id"=>"49rofLvvxCOiIMIi6mk8ai", "type"=>"Link", "linkType"=>"Entry"}}}</div>',
+        "<h2>Some subheading</h2>",
+        "<p><b>Some bold</b></p>",
+        "<p><i>Some italics</i></p>",
+        "<p><u>Some underline</u></p>",
+        "<p></p>",
+        "<p></p>",
+        '<div>{"target"=>{"sys"=>{"id"=>"5ZF9Q4K6iWSYIU2OUs0UaQ", "type"=>"Link", "linkType"=>"Entry"}}}</div>',
+        "<p></p>",
+        "<p>Some raw content</p>",
+        "<p></p>",
+        "<p>An unpublished embed:</p>",
+        "<p></p>",
+        '<div>{"target"=>{"sys"=>{"id"=>"q2hGXkd5tICym64AcgeKK", "type"=>"Link", "linkType"=>"Entry"}}}</div>',
+        "<p>Some more content</p>",
+      ].join("\n")
+    end
+  end
+
+  describe 'with all renderers overridden' do
+    subject do
+      described_class.new(
+        'heading-1' => HeadingOneMarkdownRenderer,
+        'heading-2' => HeadingTwoMarkdownRenderer,
+        'paragraph' => ParagraphMarkdownRenderer,
+        'embedded-entry-block' => EntryBlockMarkdownRenderer,
+        'bold' => BoldMarkdownRenderer,
+        'italic' => ItalicMarkdownRenderer,
+        'underline' => UnderlineMarkdownRenderer
+      )
+    end
+
+    it 'renders with the overridden renderers' do
+      expect(subject.render(full_document)).to eq [
+        "# Some heading",
+        "",
+        "",
+        "",
+        "",
+        "```",
+        '{"target"=>{"sys"=>{"id"=>"49rofLvvxCOiIMIi6mk8ai", "type"=>"Link", "linkType"=>"Entry"}}}',
+        "```",
+        "",
+        "## Some subheading",
+        "",
+        "**Some bold**",
+        "",
+        "",
+        "*Some italics*",
+        "",
+        "",
+        "__Some underline__",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "```",
+        '{"target"=>{"sys"=>{"id"=>"5ZF9Q4K6iWSYIU2OUs0UaQ", "type"=>"Link", "linkType"=>"Entry"}}}',
+        "```",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "Some raw content",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "An unpublished embed:",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "```",
+        '{"target"=>{"sys"=>{"id"=>"q2hGXkd5tICym64AcgeKK", "type"=>"Link", "linkType"=>"Entry"}}}',
+        "```",
+        "",
+        "",
+        "Some more content",
+        ""
+      ].join("\n")
+    end
+  end
+end

data/spec/lib/structured_text_renderer/text_renderers/base_inline_renderer_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+mock_node = {"value" => "foo"}
+
+describe StructuredTextRenderer::BaseInlineRenderer do
+  subject { described_class.new }
+
+  it 'renders as a span' do
+    expect(subject.render(mock_node)).to eq "<span>foo</span>"
+  end
+end

data/spec/lib/structured_text_renderer/text_renderers/bold_renderer_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+mock_node = {"value" => "foo"}
+
+describe StructuredTextRenderer::BoldRenderer do
+  subject { described_class.new }
+
+  it 'renders as a b' do
+    expect(subject.render(mock_node)).to eq "<b>foo</b>"
+  end
+end

data/spec/lib/structured_text_renderer/text_renderers/code_renderer_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+mock_node = {"value" => "foo"}
+
+describe StructuredTextRenderer::CodeRenderer do
+  subject { described_class.new }
+
+  it 'renders as a code' do
+    expect(subject.render(mock_node)).to eq "<code>foo</code>"
+  end
+end

data/spec/lib/structured_text_renderer/text_renderers/italic_renderer_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+mock_node = {"value" => "foo"}
+
+describe StructuredTextRenderer::ItalicRenderer do
+  subject { described_class.new }
+
+  it 'renders as a i' do
+    expect(subject.render(mock_node)).to eq "<i>foo</i>"
+  end
+end

data/spec/lib/structured_text_renderer/text_renderers/text_renderer_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+mock_node_underline_only = {"value" => "foo", "nodeType" => "text", "marks" => [{"type" => "underline"}]}
+
+mock_node_italic_only = {"value" => "foo", "nodeType" => "text", "marks" => [{"type" => "italic"}]}
+
+mock_node_bold_only = {"value" => "foo", "nodeType" => "text", "marks" => [{"type" => "bold"}]}
+
+mock_node_multiple_marks = {
+  "value" => "foo",
+  "nodeType" => "text",
+  "marks" => [{"type" => "underline"}, {"type" => "italic"}, {"type" => "bold"}],
+}
+
+mock_node_unsupported_mark = {"value" => "foo", "nodeType" => "text", "marks" => [{"type" => "foobar"}]}
+
+describe StructuredTextRenderer::TextRenderer do
+  subject do
+    described_class.new(
+      'text' => StructuredTextRenderer::TextRenderer,
+      'bold' => StructuredTextRenderer::BoldRenderer,
+      'italic' => StructuredTextRenderer::ItalicRenderer,
+      'underline' => StructuredTextRenderer::UnderlineRenderer,
+      nil => StructuredTextRenderer::NullRenderer
+    )
+  end
+
+  describe '#render' do
+    it 'can render with a single mark' do
+      expect(subject.render(mock_node_bold_only)).to eq "<b>foo</b>"
+      expect(subject.render(mock_node_italic_only)).to eq "<i>foo</i>"
+      expect(subject.render(mock_node_underline_only)).to eq "<u>foo</u>"
+    end
+
+    it 'can render multiple marks' do
+      expect(subject.render(mock_node_multiple_marks)).to eq "<b><i><u>foo</u></i></b>"
+    end
+
+    it 'raises an error for unsupported marks' do
+      expect { subject.render(mock_node_unsupported_mark) }.to raise_error "No renderer defined for 'foobar' nodes"
+    end
+
+    it 'supports custom renderers' do
+      subject = described_class.new(
+        'text' => StructuredTextRenderer::TextRenderer,
+        'bold' => BoldMarkdownRenderer,
+        nil => StructuredTextRenderer::NullRenderer
+      )
+
+      expect(subject.render(mock_node_bold_only)).to eq "**foo**"
+    end
+  end
+end

data/spec/lib/structured_text_renderer/text_renderers/underline_renderer_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+mock_node = {"value" => "foo"}
+
+describe StructuredTextRenderer::UnderlineRenderer do
+  subject { described_class.new }
+
+  it 'renders as a u' do
+    expect(subject.render(mock_node)).to eq "<u>foo</u>"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,82 @@
+require 'simplecov'
+SimpleCov.start unless RUBY_PLATFORM == 'java'
+
+require 'rspec'
+require 'structured_text_renderer'
+
+RSpec.configure do |config|
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end
+
+class NodeRenderer
+  attr_reader :mappings
+
+  def initialize(mappings = {})
+    @mappings = mappings
+  end
+
+  protected
+
+  def find_renderer(node)
+    renderer = mappings[node['nodeType']]
+    return if renderer.nil?
+    renderer.new(mappings)
+  end
+end
+
+class HeadingOneMarkdownRenderer < NodeRenderer
+  def render(node)
+    node['content'].each_with_object([]) do |c, res|
+      renderer = find_renderer(c)
+      next if renderer.nil?
+      res << "# #{renderer.render(c)}"
+    end.join("\n")
+  end
+end
+
+class HeadingTwoMarkdownRenderer < NodeRenderer
+  def render(node)
+    node['content'].each_with_object([]) do |c, res|
+      renderer = find_renderer(c)
+      next if renderer.nil?
+      res << "## #{renderer.render(c)}"
+    end.join("\n")
+  end
+end
+
+class ParagraphMarkdownRenderer < NodeRenderer
+  def render(node)
+    paragraphs = node['content'].each_with_object([]) do |c, res|
+      renderer = find_renderer(c)
+      next if renderer.nil?
+      res << "#{renderer.render(c)}"
+    end.join("\n")
+
+    "\n#{paragraphs}\n"
+  end
+end
+
+class EntryBlockMarkdownRenderer < NodeRenderer
+  def render(node)
+    "\n```\n#{node['data']}\n```\n"
+  end
+end
+
+class BoldMarkdownRenderer < NodeRenderer
+  def render(node)
+    "**#{node['value']}**"
+  end
+end
+
+class ItalicMarkdownRenderer < NodeRenderer
+  def render(node)
+    "*#{node['value']}*"
+  end
+end
+
+class UnderlineMarkdownRenderer < NodeRenderer
+  def render(node)
+    "__#{node['value']}__"
+  end
+end