sinicum 0.5.0

data/spec/fixtures/api/query_result.json

@@ -0,0 +1,61 @@
+[ {
+  "properties" : { },
+  "nodes" : {
+    "MetaData" : {
+      "properties" : { },
+      "nodes" : { },
+      "meta" : {
+        "name" : "MetaData",
+        "path" : "/path/subpage1/MetaData",
+        "workspace" : "website",
+        "depth" : 3,
+        "mixinNodeTypes" : [ ],
+        "superTypes" : [ "mix:referenceable", "nt:base", "nt:hierarchyNode" ],
+        "jcr:uuid" : "f7a6d0b9-e6e9-470b-881d-967bab1e7f76",
+        "jcr:primaryType" : "mgnl:metaData",
+        "jcr:created" : "2013-06-03T10:17:45.260+02:00"
+      }
+    }
+  },
+  "meta" : {
+    "name" : "subpage1",
+    "path" : "/path/subpage1",
+    "workspace" : "website",
+    "depth" : 2,
+    "mixinNodeTypes" : [ ],
+    "superTypes" : [ "mix:referenceable", "nt:base", "nt:hierarchyNode", "mgnl:content" ],
+    "jcr:uuid" : "995a776f-242e-453a-9422-d0b7e8e9c068",
+    "jcr:primaryType" : "mgnl:page",
+    "jcr:created" : "2013-06-03T10:17:45.260+02:00"
+  }
+}, {
+  "properties" : { },
+  "nodes" : {
+    "MetaData" : {
+      "properties" : { },
+      "nodes" : { },
+      "meta" : {
+        "name" : "MetaData",
+        "path" : "/path/subpage2/MetaData",
+        "workspace" : "website",
+        "depth" : 3,
+        "mixinNodeTypes" : [ ],
+        "superTypes" : [ "mix:referenceable", "nt:base", "nt:hierarchyNode" ],
+        "jcr:uuid" : "c37083de-6a57-48fe-95d0-41fe05fb2ac5",
+        "jcr:primaryType" : "mgnl:metaData",
+        "jcr:created" : "2013-06-03T10:17:45.260+02:00"
+      }
+    }
+  },
+  "meta" : {
+    "name" : "subpage2",
+    "path" : "/path/subpage2",
+    "workspace" : "website",
+    "depth" : 2,
+    "mixinNodeTypes" : [ ],
+    "superTypes" : [ "mix:referenceable", "nt:base", "nt:hierarchyNode", "mgnl:content" ],
+    "jcr:uuid" : "bba4bfcd-8347-40d0-9bb6-504ddde1c5a1",
+    "jcr:primaryType" : "mgnl:page",
+    "jcr:created" : "2013-06-03T10:17:45.260+02:00"
+  }
+} ]

data/spec/fixtures/mock_content.rb

@@ -0,0 +1,6 @@
+class MockContent < Sinicum::Jcr::Content
+  def initialize(workspace_name = "website", content = {})
+    content[:uuid] = Sinicum::Jcr::Content.new_uuid unless content.key?(:uuid)
+    initialize_original_content(workspace_name, content)
+  end
+end

data/spec/helpers/sinicum/helper_utils_spec.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rexml/document'
+
+module Sinicum
+  describe HelperUtils do
+    describe "#object_from_key_or_object" do
+      it "should return the node if a node is given as an argument" do
+        node = Jcr::Node.new
+        helper.send(:object_from_key_or_object, node).should eq(node)
+      end
+
+      it "should query for the node if a UUID is given" do
+        uuid = "f082dc7a-c23c-42bf-8338-60a6bd5a777b"
+        node = Jcr::Node.new
+        Jcr::Node.should_receive(:find_by_uuid).with("website", uuid).and_return(node)
+        helper.send(:object_from_key_or_object, uuid, "website").should eq(node)
+      end
+
+      it "should return the property from the current content data if a symbol is given" do
+        begin
+          content = { title: "Title" }
+          Content::Aggregator.original_content = content
+          helper.send(:object_from_key_or_object, :title).should eq("Title")
+        ensure
+          Content::Aggregator.clean
+        end
+      end
+    end
+
+    describe "#fingerprint_in_asset_path" do
+      it "should return when a fingerprint is in the path" do
+        helper.send(
+          :fingerprint_in_asset_path,
+          "/damfiles/image_text_button/home_welcome-841fef0a3e62db91ea8cc9feea6d87a4.jpg"
+        ).should be true
+      end
+
+      it "should return true when a fingerprint is in the path and the suffix is missing" do
+        helper.send(
+          :fingerprint_in_asset_path,
+          "/damfiles/image_text_button/home_welcome-841fef0a3e62db91ea8cc9feea6d87a4"
+        ).should be true
+      end
+
+      it "should return false when a fingerprint is not in the path" do
+        helper.send(
+          :fingerprint_in_asset_path,
+          "/damfiles/image_text_button/home_welcome"
+        ).should be false
+      end
+    end
+
+  end
+end

data/spec/helpers/sinicum/mgnl_helper_spec.rb

@@ -0,0 +1,315 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rexml/document'
+
+module Sinicum
+  describe MgnlHelper do
+    describe "#mgnl_path" do
+      let(:node) do
+        node = Jcr::Node.new
+        node.stub(:jcr_path).and_return("/the/path")
+        node
+      end
+
+      let(:document) do
+        node = Jcr::Dam::Document.new
+        node.stub(:jcr_path).and_return("/the/path")
+        doc = double("document")
+        node.stub(:[]).and_return(nil)
+        node.stub(:[]).with(:'jcr:content').and_return(doc)
+        doc.stub(:[]).and_return(nil)
+        node
+      end
+
+      it "should return a node's path" do
+        helper.mgnl_path(node).should eq("/the/path")
+      end
+
+      it "should return the right path for a UUID string" do
+        Jcr::Node.should_receive(:find_by_uuid)
+          .with("website", "900985a3-319c-41c6-b327-b46d7fb56d23")
+          .and_return(node)
+
+        helper.mgnl_path("900985a3-319c-41c6-b327-b46d7fb56d23").should eq("/the/path")
+      end
+
+      it "should handle other repositories than the website" do
+        Jcr::Node.should_receive(:find_by_uuid)
+          .with("dam", "900985a3-319c-41c6-b327-b46d7fb56d23")
+          .and_return(node)
+
+        helper.mgnl_path("900985a3-319c-41c6-b327-b46d7fb56d23", workspace: "dam")
+          .should eq("/the/path")
+      end
+
+      it "should ignore the renderer when the node is not a document" do
+        helper.mgnl_path(node, renderer: "video").should eq("/the/path")
+      end
+
+      it "should work with the renderer when the node is a document" do
+        helper.mgnl_path(document, renderer: "video").should eq(
+          "/damfiles/video/the/path-fc308f85a906fce1be5ff58fd2853af5")
+      end
+
+      it "should return a string if the path given is a string" do
+        helper.mgnl_path("/some/path").should eq("/some/path")
+      end
+
+      it "should return a string if the property that defines the link returns a string" do
+        Jcr::Node.should_receive(:find_by_uuid)
+          .with("website", "900985a3-319c-41c6-b327-b46d7fb56d23")
+          .and_return("/some/path")
+        helper.mgnl_path("900985a3-319c-41c6-b327-b46d7fb56d23", workspace: "website")
+          .should eq("/some/path")
+      end
+    end
+
+    describe "#mgnl_content_data" do
+      it "should return the current content data from the aggregator" do
+        content = double(:content)
+        Content::Aggregator.should_receive(:content_data).and_return(content)
+        helper.mgnl_content_data.should eq(content)
+      end
+    end
+
+    describe "#mgnl_link" do
+      it "should pass through a string as a link" do
+        doc = REXML::Document.new(helper.mgnl_link("/path/to/link"))
+        doc.elements["a"].attributes["href"].should eq("/path/to/link")
+      end
+
+      it "should pass through a string as a link when a block is given" do
+        doc = REXML::Document.new(helper.mgnl_link("/path/to/link") { "something" })
+        doc.elements["a"].attributes["href"].should eq("/path/to/link")
+      end
+    end
+
+    describe "#push" do
+      after(:each) do
+        Content::Aggregator.clean
+      end
+
+      it "should push content" do
+        node = Jcr::Node.new
+        block_called = false
+        helper.mgnl_push(node) do
+          block_called = true
+          Content::Aggregator.content_data.should eq(node)
+        end
+        block_called.should be true
+        Content::Aggregator.content_data.should be nil
+      end
+
+      it "should not yield if no content is found"
+
+      it "should resolve a UUID if a UUID is returned"
+    end
+
+    describe "#mgnl_original_content" do
+      it "should fetch the original content"
+    end
+
+    describe "#mgnl_out" do
+      let(:node) do
+        node = Jcr::Node.new
+        node.stub(:title).and_return("The title")
+        node
+      end
+
+      before(:each) do
+        Content::Aggregator.stub(:original_content).and_return(node)
+      end
+
+      it "should output a property" do
+        helper.mgnl_out(:title).should eq("The title")
+      end
+
+      it "should output an empty string if the property does not exist" do
+        helper.mgnl_out(:some_unknown_attribute).should eq("")
+      end
+    end
+
+    describe "#mgnl_meta" do
+      it "should display a title" do
+        Sinicum::Content::Aggregator.push(title: "My Headline") do
+          result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+          result.root.elements['title'].size.should eq(1)
+        end
+      end
+
+      it "should remove tags from the title" do
+        Sinicum::Content::Aggregator.push(title: "my <b>bold</b> title") do
+          result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+          result.root.elements['title'].size.should eq(1)
+          result.root.elements['title'].first.to_s.should eq("my bold title")
+        end
+      end
+
+      it "should prefer meta_title for the title" do
+        Sinicum::Content::Aggregator.push(meta_title: "Preferred title") do
+          result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+          result.root.elements['title'].first.to_s.should eq("Preferred title")
+        end
+      end
+
+      it "should add a prefix for the title" do
+        Sinicum::Content::Aggregator.push(title: "My Headline") do
+          result = REXML::Document.new("<div>" +
+            helper.mgnl_meta(title_prefix: "The Prefix") + "</div>")
+          result.root.elements['title'].first.to_s.should eq("The Prefix – My Headline")
+        end
+      end
+
+      it "should add a suffix for the title" do
+        Sinicum::Content::Aggregator.push(title: "My Headline") do
+          result = REXML::Document.new("<div>" +
+            helper.mgnl_meta(title_suffix: "The Suffix") + "</div>")
+          result.root.elements['title'].first.to_s.should eq("My Headline – The Suffix")
+        end
+      end
+
+      it "should not add a delimiter after the prefix if no title is present" do
+        Sinicum::Content::Aggregator.push({}) do
+          result = REXML::Document.new("<div>" +
+            helper.mgnl_meta(title_prefix: "The Prefix") + "</div>")
+          result.root.elements['title'].first.to_s.should eq("The Prefix")
+        end
+      end
+
+      it "should not add a delimiter before the suffix if no title is present" do
+        Sinicum::Content::Aggregator.push({}) do
+          result = REXML::Document.new("<div>" +
+            helper.mgnl_meta(title_prefix: "The Suffix") + "</div>")
+          result.root.elements['title'].first.to_s.should eq("The Suffix")
+        end
+      end
+
+      it "should not add an emtpy title attribute if no title is defined" do
+        Sinicum::Content::Aggregator.push({}) do
+          result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+          result.root.elements['title'].first.to_s.should eq("")
+        end
+      end
+
+      it "should display a desciption tag" do
+        Sinicum::Content::Aggregator.push(meta_description: "A Description") do
+          result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+          result.root.elements["meta[@name = 'description']"].attributes["content"]
+            .should eq("A Description")
+        end
+      end
+
+      it "should not display a desciption tag if no description is given" do
+        result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+        result.root.elements["meta[@name = 'description']"].should be nil
+      end
+
+      it "should display a keywords tag" do
+        Sinicum::Content::Aggregator.push(meta_keywords: "some keyowrds") do
+          result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+          result.root.elements["meta[@name = 'keywords']"].attributes["content"]
+            .should eq("some keyowrds")
+        end
+      end
+
+      it "should not display a keywords tag if no description is given" do
+        result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+        result.root.elements["meta[@name = 'keywords']"].should be nil
+      end
+
+      it "should display 'robots: noindex,nofollow' tag" do
+        Sinicum::Content::Aggregator.push(meta_noindex: true) do
+          result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+          result.root.elements["meta[@name = 'robots']"].attributes["content"].should =~ /noindex/
+          result.root.elements["meta[@name = 'robots']"].attributes["content"].should =~ /nofollow/
+        end
+      end
+
+      it "should display no 'robots' tag by default" do
+        result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+        result.root.elements["meta[@name = 'robots']"].should be nil
+      end
+
+      it "should display a language tag" do
+        result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+        result.root.elements["meta[@name = 'language']"].attributes["content"]
+          .should eq(I18n.locale.to_s)
+      end
+
+      it "should display the content type tag" do
+        result = REXML::Document.new("<div>" + helper.mgnl_meta + "</div>")
+        result.root.elements["meta[@http-equiv = 'content-type']"].attributes["content"]
+          .should eq("text/html; charset=utf-8")
+      end
+
+      it "should be html_safe" do
+        helper.mgnl_meta.should be_html_safe
+      end
+    end
+
+    describe "#mgnl_navigation" do
+      let(:handler) { double "handler" }
+      let(:el1) { double("el1") }
+      let(:el2) { double("el2") }
+      let(:elements) { [el1, el2] }
+
+      describe "path based" do
+        before(:each) do
+          Navigation::NavigationHandler.should_receive(:children).with("/de", 3)
+            .and_return(handler)
+          handler.should_receive(:elements).and_return(elements)
+        end
+
+        it "should the children navigation handler" do
+          helper.mgnl_navigation("/de", :children, depth: 3)
+        end
+
+        it "should yield the block" do
+          expect { |arg|  elements.each(&arg) }.to yield_successive_args(el1, el2)
+          helper.mgnl_navigation("/de", :children, depth: 3) { |nav| }
+        end
+
+        it "should retun the elements if no block given" do
+          result = helper.mgnl_navigation("/de", :children, depth: 3)
+          result.size.should eq(2)
+        end
+      end
+
+      describe "node based" do
+        let(:node) { double("node") }
+
+        before(:each) do
+          Navigation::NavigationHandler.should_receive(:children).with(node, 3)
+            .and_return(handler)
+          handler.should_receive(:elements).and_return(elements)
+        end
+
+        it "should the children navigation handler" do
+          helper.mgnl_navigation(node, :children, depth: 3)
+        end
+      end
+
+      describe "path based parents" do
+        before(:each) do
+          Navigation::NavigationHandler.should_receive(:parents).with("/de")
+            .and_return(handler)
+          handler.should_receive(:elements).and_return(elements)
+        end
+
+        it "should the children navigation handler" do
+          helper.mgnl_navigation("/de", :parents)
+        end
+
+        it "should yield the block" do
+          expect { |arg|  elements.each(&arg) }.to yield_successive_args(el1, el2)
+          helper.mgnl_navigation("/de", :parents) { |nav| }
+        end
+
+        it "should return the elements if no block given" do
+          elements = helper.mgnl_navigation("/de", :parents)
+          elements.size.should eq(2)
+        end
+      end
+    end
+  end
+end

data/spec/helpers/sinicum/mgnl_image_helper_spec.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rexml/document'
+
+module Sinicum
+  describe MgnlHelper do
+    let(:uuid) { "900985a3-319c-41c6-b327-b46d7fb56d23" }
+    let(:image_node) do
+      doc = double("document")
+      image_node = Jcr::Dam::Image.new
+      image_node.stub(:jcr_path).and_return("/the/path")
+      image_node.stub(:"[]").and_return(nil)
+      image_node.stub(:width).and_return(100)
+      image_node.stub(:height).and_return(50)
+      image_node.stub(:width).with("title").and_return(200)
+      image_node.stub(:height).with("title").and_return(100)
+      image_node.stub(:[]).with(:'jcr:content').and_return(doc)
+      doc.stub(:[]).and_return(nil)
+      image_node
+    end
+
+    context "when an image exists" do
+      before(:each) do
+        Jcr::Node.should_receive(:find_by_uuid).with("dam", uuid).and_return(image_node)
+      end
+
+      it "should return the image path" do
+        doc = REXML::Document.new(helper.mgnl_img(uuid, renderer: "title"))
+        doc.elements["img"].attributes["src"].should eq(
+          "/damfiles/title/the/path-fc308f85a906fce1be5ff58fd2853af5")
+      end
+
+      it "should return the image path with source url" do
+        helper.stub(:compute_asset_host).and_return("http://www.dievision.de")
+        doc = REXML::Document.new(helper.mgnl_img(uuid, renderer: "title"))
+        doc.elements["img"].attributes["src"].should eq(
+          "http://www.dievision.de/damfiles/title/the/path-fc308f85a906fce1be5ff58fd2853af5")
+        Rails.configuration.action_controller.asset_host = nil
+      end
+
+      it "should return a default renderer if no renderer is given" do
+        doc = REXML::Document.new(helper.mgnl_img(uuid))
+        doc.elements["img"].attributes["src"].should eq(
+          "/damfiles/default/the/path-fc308f85a906fce1be5ff58fd2853af5")
+      end
+
+      it "should create the right alt tag" do
+        image_node.stub(:'[]').with(:subject).and_return("alttext")
+        doc = REXML::Document.new(helper.mgnl_img(uuid, renderer: "title"))
+        doc.elements["img"].attributes["alt"].should eq("alttext")
+      end
+
+      it "should return an empty alt tag if no subject is given" do
+        doc = REXML::Document.new(helper.mgnl_img(uuid, renderer: "title"))
+        doc.elements["img"].attributes["alt"].should eq("")
+      end
+
+      it "should return the height and the width attribute" do
+        doc = REXML::Document.new(helper.mgnl_img(uuid))
+        doc.elements["img"].attributes["width"].should eq("100")
+        doc.elements["img"].attributes["height"].should eq("50")
+      end
+
+      it "should consider the renderer for the image size" do
+        doc = REXML::Document.new(helper.mgnl_img(uuid, renderer: "title"))
+        doc.elements["img"].attributes["width"].should eq("200")
+        doc.elements["img"].attributes["height"].should eq("100")
+      end
+
+      it "should not render the width if width is false" do
+        doc = REXML::Document.new(helper.mgnl_img(uuid, renderer: "title", width: false))
+        doc.elements["img"].attributes["width"].should be_nil
+      end
+
+      it "should not render the height if height is false" do
+        doc = REXML::Document.new(helper.mgnl_img(uuid, renderer: "title", height: false))
+        doc.elements["img"].attributes["height"].should be_nil
+      end
+
+      it "should allow for custom height and width attributes" do
+        doc = REXML::Document.new(helper.mgnl_img(
+          uuid, renderer: "title", width: "85%", height: "33%"))
+        doc.elements["img"].attributes["width"].should eq("85%")
+        doc.elements["img"].attributes["height"].should eq("33%")
+      end
+
+      it "should be possible to add a class attribute" do
+        doc = REXML::Document.new(helper.mgnl_img(uuid, class: "someclass"))
+        doc.elements["img"].attributes["class"].should eq("someclass")
+      end
+
+      it "should be possible to add a any random attribute attribute" do
+        doc = REXML::Document.new(helper.mgnl_img(uuid, :'data-something' => "data"))
+        doc.elements["img"].attributes["data-something"].should eq("data")
+      end
+    end
+
+    it "should return nil if no image is found" do
+      Jcr::Node.should_receive(:find_by_uuid).with("dam", uuid).and_return(nil)
+      helper.mgnl_img(uuid, renderer: "title").should be nil
+    end
+  end
+end