shortcode 1.2.1 → 2.0.0.pre

data/spec/shortcode/parser_spec.rb

@@ -0,0 +1,313 @@
+# rubocop:disable RSpec/ExampleLength
+require "spec_helper"
+require "parslet/rig/rspec"
+require "pp"
+
+describe Shortcode::Parser do
+  let(:configuration) { Shortcode.new.configuration }
+  let(:parser) { described_class.new(configuration) }
+
+  let(:simple_quote)      { load_fixture :simple_quote }
+  let(:full_quote)        { load_fixture :full_quote }
+  let(:without_quotes)    { load_fixture :without_quotes }
+  let(:quote_with_extras) { load_fixture :quote_with_extras }
+  let(:simple_list)       { load_fixture :simple_list }
+  let(:timeline_event)    { load_fixture :timeline_event }
+  let(:timeline_info)     { load_fixture :timeline_info }
+  let(:timeline_person)   { load_fixture :timeline_person }
+  let(:complex_snippet)   { load_fixture :complex_snippet }
+
+  let(:quotes)            { [simple_quote, full_quote, quote_with_extras] }
+  let(:collapsible_lists) { [simple_list] }
+  let(:timelines)         { [timeline_event, timeline_info, timeline_person] }
+
+  it "parses quote shortcodes" do
+    quotes.each do |string|
+      expect(parser).to parse(string)
+    end
+  end
+
+  describe "matching similar tags" do
+    context "with the smaller tag listed first" do
+      before do
+        configuration.block_tags = %i[xx xxx]
+      end
+
+      it "parses xx" do
+        expect(parser.open).to parse("[xx]")
+      end
+
+      it "parses xxx" do
+        expect(parser.open).to parse("[xxx]")
+      end
+    end
+
+    context "with the smaller tag listed last" do
+      before do
+        configuration.block_tags = %i[xxx xx]
+      end
+
+      it "parses xx" do
+        expect(parser.open).to parse("[xx]")
+      end
+
+      it "parses xxx" do
+        expect(parser.open).to parse("[xxx]")
+      end
+    end
+  end
+
+  context "attribute_quote_type configuration" do
+    before do
+      configuration.attribute_quote_type = "'"
+    end
+
+    it "parses quotes using custom quotations" do
+      quotes.each do |string|
+        # Change double quotes to single quotes in the fixture
+        expect(parser).to parse(string.tr('"', "'"))
+      end
+    end
+  end
+
+  context "use_attribute_quotes configuration" do
+    before do
+      configuration.use_attribute_quotes = false
+    end
+
+    it "parses shortcodes with optional quotes" do
+      expect(parser).to parse(without_quotes)
+    end
+  end
+
+  it "parses list shortcodes" do
+    collapsible_lists.each do |string|
+      expect(parser).to parse(string)
+    end
+  end
+
+  it "parses timeline shortcodes" do
+    timelines.each do |string|
+      expect(parser).to parse(string)
+    end
+  end
+
+  it "parses complex nested shortcodes" do
+    expect(parser).to parse(complex_snippet)
+  end
+
+  describe "parsed strings" do
+    context "simple_quote" do
+      let(:parsed_object) { parser.parse(simple_quote) }
+
+      before do
+        configuration.block_tags = [:quote]
+      end
+
+      it "created the expected object" do
+        expect(parsed_object[:body])
+          .to eq([{ open: "quote", options: [], inner: [{ text: "hello" }], close: "quote" }])
+      end
+    end
+
+    context "full_quote" do
+      let(:parsed_object) { parser.parse(full_quote) }
+
+      before do
+        configuration.block_tags = [:quote]
+      end
+
+      it "created the expected object" do
+        expect(parsed_object[:body]).to eq([{
+                                             open: "quote",
+                                             options: [
+                                               { key: "author", value: "Jamie Dyer" },
+                                               { key: "title", value: "King of England" }
+                                             ],
+                                             inner: [{ text: "A quote" }],
+                                             close: "quote"
+                                           }])
+      end
+    end
+
+    context "quote_with_extras" do
+      let(:parsed_object) { parser.parse(quote_with_extras) }
+
+      before do
+        configuration.block_tags = [:quote]
+      end
+
+      it "created the expected object" do
+        expect(parsed_object[:body]).to eq([
+                                             { text: "Blah blah " },
+                                             {
+                                               open: "quote",
+                                               options: [
+                                                 { key: "author", value: "Jamie Dyer" }
+                                               ],
+                                               inner: [{ text: "A quote" }],
+                                               close: "quote"
+                                             },
+                                             { text: " <br> blah blah\n" }
+                                           ])
+      end
+    end
+
+    context "simple_list" do
+      let(:parsed_object) { parser.parse(simple_list) }
+
+      before do
+        configuration.block_tags = %i[collapsible_list item]
+      end
+
+      it "created the expected object" do
+        expect(parsed_object[:body]).to eq([{
+                                             open: "collapsible_list",
+                                             options: [],
+                                             inner: [{
+                                               open: "item",
+                                               options: [{ key: "title", value: "Example title 1" }],
+                                               inner: [{ text: "Example content 1" }],
+                                               close: "item"
+                                             },
+                                                     {
+                                                       open: "item",
+                                                       options: [{ key: "title", value: "Example title 2" }],
+                                                       inner: [{ text: "Example content 2" }],
+                                                       close: "item"
+                                                     },
+                                                     {
+                                                       open: "item",
+                                                       options: [{ key: "title", value: "Example title 3" }],
+                                                       inner: [{ text: "Example content 3" }],
+                                                       close: "item"
+                                                     }],
+                                             close: "collapsible_list"
+                                           }])
+      end
+    end
+
+    context "timeline_event" do
+      let(:parsed_object) { parser.parse(timeline_event) }
+
+      before do
+        configuration.self_closing_tags = [:timeline_event]
+      end
+
+      it "created the expected object" do
+        expect(parsed_object[:body]).to eq([{
+                                             open_close: "timeline_event",
+                                             options: [
+                                               { key: "date", value: "March 2013" },
+                                               { key: "title", value: "a title" },
+                                               { key: "link", value: "http://blah.com" }
+                                             ]
+                                           }])
+      end
+    end
+
+    context "timeline_info" do
+      let(:parsed_object) { parser.parse(timeline_info) }
+
+      before do
+        configuration.self_closing_tags = [:timeline_info]
+      end
+
+      it "created the expected object" do
+        expect(parsed_object[:body]).to eq([{
+                                             open_close: "timeline_info",
+                                             options: [
+                                               { key: "date", value: "Feb 2013" },
+                                               { key: "title", value: "Something amazing" }
+                                             ]
+                                           }])
+      end
+    end
+
+    context "timeline_person" do
+      let(:parsed_object) { parser.parse(timeline_person) }
+
+      before do
+        configuration.block_tags = [:timeline_person]
+      end
+
+      it "created the expected object" do
+        expect(parsed_object[:body]).to eq([{
+                                             open: "timeline_person",
+                                             options: [
+                                               { key: "date", value: "Jan 2012" },
+                                               { key: "title", value: "A real title" },
+                                               { key: "image", value: "/images/person.jpg" },
+                                               { key: "name", value: "Sam Smith" },
+                                               { key: "position", value: "Presedent" },
+                                               { key: "link", value: "http://blah.com" }
+                                             ],
+                                             inner: [{ text: "A bit of body copy\nwith a newline\n" }],
+                                             close: "timeline_person"
+                                           }])
+      end
+    end
+
+    context "complex_snippet" do
+      let(:parsed_object) { parser.parse(complex_snippet) }
+
+      before do
+        configuration.block_tags = %i[quote collapsible_list item]
+      end
+
+      it "created the expected object" do
+        expect(parsed_object[:body]).to eq(
+          [
+            { text: "<h3>A page title</h3>\n<p>Some text</p>\n" },
+            {
+              open: "collapsible_list",
+              options: [],
+              inner: [
+                {
+                  open: "item",
+                  options: [{ key: "title", value: "Example title 1" }],
+                  inner: [
+                    {
+                      open: "quote",
+                      options: [
+                        { key: "author", value: "Jamie Dyer" },
+                        { key: "title", value: "King of England" }
+                      ],
+                      inner: [{ text: "A quote" }],
+                      close: "quote"
+                    },
+                    { text: "I'm inbetween 2 quotes!\n    " },
+                    {
+                      open: "quote",
+                      options: [
+                        { key: "author", value: "Forrest Gump" },
+                        { key: "title", value: "Idiot" }
+                      ],
+                      inner: [{ text: "Life is like..." }],
+                      close: "quote"
+                    }
+                  ],
+                  close: "item"
+                },
+                {
+                  open: "item",
+                  options: [{ key: "title", value: "Example title 2" }],
+                  inner: [{ text: "Example content 2" }],
+                  close: "item"
+                },
+                {
+                  open: "item",
+                  options: [{ key: "title", value: "Example title 3" }],
+                  inner: [{ text: "Example content 3" }],
+                  close: "item"
+                }
+              ],
+              close: "collapsible_list"
+            },
+            { text: "\n<p>Some more text</p>\n" }
+          ]
+        )
+      end
+    end
+  end
+end

data/spec/shortcode/presenter_spec.rb

@@ -0,0 +1,118 @@
+require "spec_helper"
+require "parslet/rig/rspec"
+require "pp"
+
+require "support/presenters/my_presenter"
+require "support/presenters/other_presenter"
+require "support/presenters/multiple_presenter"
+require "support/presenters/missing_for_presenter"
+require "support/presenters/missing_initialize_presenter"
+require "support/presenters/missing_content_presenter"
+require "support/presenters/missing_attributes_presenter"
+
+describe Shortcode::Presenter do
+  let(:shortcode) { Shortcode.new }
+  let(:configuration) { shortcode.configuration }
+  let(:simple_quote)  { load_fixture :simple_quote }
+  let(:item)          { load_fixture :item }
+
+  before do
+    configuration.block_tags = %i[quote item]
+    configuration.template_path = File.join File.dirname(__FILE__), "../support/templates/erb"
+  end
+
+  describe "using a custom presenter" do
+    let(:presenter_output)  { load_fixture :simple_quote_presenter_output, :html }
+    let(:attributes_output) { load_fixture :simple_quote_presenter_attributes_output, :html }
+
+    before do
+      shortcode.register_presenter MyPresenter
+    end
+
+    it "uses the custom attributes" do
+      expect(shortcode.process(simple_quote).delete("\n")).to eq(presenter_output)
+    end
+
+    it "passes through additional attributes" do
+      expect(shortcode.process(simple_quote, title: "Additional attribute title").delete("\n"))
+        .to eq(attributes_output)
+    end
+  end
+
+  describe "using a single presenter for multiple shortcodes" do
+    let(:quote_presenter_output)  { load_fixture :simple_quote_presenter_output, :html }
+    let(:item_presenter_output)   { load_fixture :item_presenter_output,         :html }
+
+    let(:quote_attributes_output) { load_fixture :simple_quote_presenter_attributes_output, :html }
+    let(:item_attributes_output)  { load_fixture :item_presenter_attributes_output,         :html }
+
+    before do
+      shortcode.register_presenter MultiplePresenter
+    end
+
+    it "uses the custom attributes" do
+      expect(shortcode.process(simple_quote).delete("\n")).to eq(quote_presenter_output)
+      expect(shortcode.process(item).delete("\n")).to eq(item_presenter_output)
+    end
+
+    it "passes through additional attributes" do
+      expect(shortcode.process(simple_quote, title: "Additional attribute title").delete("\n"))
+        .to eq(quote_attributes_output)
+      expect(shortcode.process(item, title: "Additional attribute title").delete("\n"))
+        .to eq(item_attributes_output)
+    end
+  end
+
+  context "presenter registration" do
+    describe "registering a single presenter" do
+      before do
+        shortcode.register_presenter MyPresenter
+      end
+
+      it "adds the presenter to the list" do
+        expect(configuration.presenters).to include(MyPresenter.for)
+      end
+    end
+
+    describe "registering multiple presenters" do
+      before do
+        shortcode.register_presenter(MyPresenter, OtherPresenter)
+      end
+
+      it "adds the presenter to the list" do
+        expect(configuration.presenters).to include(MyPresenter.for)
+        expect(configuration.presenters).to include(OtherPresenter.for)
+      end
+    end
+  end
+
+  context "presenter validation" do
+    describe "missing #for class method" do
+      it "raises an exception" do
+        expect { shortcode.register_presenter MissingForPresenter }
+          .to raise_error(ArgumentError, "The presenter must define the class method #for")
+      end
+    end
+
+    describe "missing #initialize method" do
+      it "raises an exception" do
+        expect { shortcode.register_presenter MissingInitializePresenter }
+          .to raise_error(ArgumentError, "The presenter must define an initialize method")
+      end
+    end
+
+    describe "missing #content method" do
+      it "raises an exception" do
+        expect { shortcode.register_presenter MissingContentPresenter }
+          .to raise_error(ArgumentError, "The presenter must define the method #content")
+      end
+    end
+
+    describe "missing #attributes method" do
+      it "raises an exception" do
+        expect { shortcode.register_presenter MissingAttributesPresenter }
+          .to raise_error(ArgumentError, "The presenter must define the method #attributes")
+      end
+    end
+  end
+end

data/spec/shortcode/tag_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe Shortcode::Tag do
+  let(:configuration) {
+    Shortcode.new.tap { |s|
+      s.setup do |config|
+        config.template_path = File.join File.dirname(__FILE__), "../support/templates/erb"
+      end
+    }.configuration
+  }
+
+  context "when the template file is missing" do
+    let(:tag) { described_class.new("doesnt_exist", configuration) }
+
+    it "raises a TemplateNotFound error when the file doesn't exists" do
+      expect { tag.render }.to raise_error(Shortcode::TemplateNotFound)
+    end
+  end
+
+  context "when an unsupported template parser is specified" do
+    before do
+      configuration.template_parser = :something_crazy
+    end
+
+    let(:tag) { described_class.new("quote", configuration) }
+
+    it "raises a TemplateNotFound error when the file doesn't exists" do
+      expect { tag.render }.to raise_error(Shortcode::TemplateParserNotSupported)
+    end
+  end
+
+  context "templates from strings" do
+    let(:tag) { described_class.new("from_string", configuration, [{ key: "string", value: "batman" }]) }
+
+    before do
+      configuration.templates[:from_string] = "<p><%= @attributes[:string] %></p>"
+    end
+
+    it "renders a template from a string" do
+      expect(tag.render).to eq("<p>batman</p>")
+    end
+  end
+
+  context "when the template is missing from the config" do
+    let(:tag) { described_class.new("missing", configuration, [{ key: "string", value: "batman" }]) }
+
+    before do
+      configuration.templates[:from_string] = "<p><%= @attributes[:string] %></p>"
+    end
+
+    it "raises an error" do
+      expect { tag.render }.to raise_error(Shortcode::TemplateNotFound)
+    end
+  end
+
+  context "when templates exist both in configuration and file system" do
+    let(:tag) { described_class.new("quote", configuration) }
+
+    before do
+      configuration.templates[:quote] = "<p><%= @content %></p>"
+    end
+
+    it "uses the configuration template when check_config_templates_first is true" do
+      expect(tag.markup).to eq("<p><%= @content %></p>")
+    end
+
+    it "uses the file system template when check_config_templates_first is false" do
+      configuration.check_config_templates_first = false
+
+      expect(tag.markup).to eq(File.open("spec/support/templates/erb/quote.html.erb").read)
+    end
+  end
+end