sinicum 0.5.0

data/app/controllers/sinicum/controllers/global_state_cache.rb

@@ -0,0 +1,83 @@
+module Sinicum
+  module Controllers
+    # Public: Filter to cache the result of a page if no changes in Magnolia
+    # occured.
+    class GlobalStateCache
+      DEPLOY_REVISION_FILE = "REVISION"
+      THREAD_LOCAL_VAR_NAME = "__sinicum_global_state_cache"
+
+      def initialize(controller)
+        @controller = controller
+        @global_jcr_cache_key = Sinicum::Jcr::Cache::GlobalCache.new.current_key
+      end
+
+      def self.before(controller)
+        if do_cache?
+          instance = new(controller)
+          Thread.current[THREAD_LOCAL_VAR_NAME] = instance
+          instance.render_or_proceed
+        end
+      end
+
+      def self.after(controller)
+        if do_cache?
+          begin
+            instance = Thread.current[THREAD_LOCAL_VAR_NAME]
+            instance.cache_response if instance
+          ensure
+            Thread.current[THREAD_LOCAL_VAR_NAME] = nil
+          end
+        end
+      end
+
+      def render_or_proceed
+        cached = Rails.cache.fetch(cache_key)
+        if cached
+          @controller.response.cache_control.merge!(cached[:cache_control])
+          @controller.response.status = cached[:status]
+          @controller.response.headers["X-SCache"] = "true"
+          @controller.render text: cached[:body]
+        else
+          @controller.response.headers["X-SCache"] = "false"
+        end
+      end
+
+      def cache_response
+        response = @controller.response
+        if @controller.request.get? && response.cache_control[:public] &&
+            response.cache_control[:max_age] && response.cache_control[:max_age] > 0
+          cache_content = {
+            body: response.body,
+            cache_control: response.cache_control,
+            status: response.status
+          }
+          Rails.cache.write(cache_key, cache_content)
+        end
+      end
+
+      private
+
+      def cache_key
+        @cache_key ||= [
+          @controller.request.base_url + @controller.request.fullpath,
+          @global_jcr_cache_key, self.class.deploy_revision
+        ]
+        @cache_key
+      end
+
+      def self.deploy_revision
+        unless @deploy_revision
+          revision_file = File.join(Rails.root, DEPLOY_REVISION_FILE)
+          if File.exist?(revision_file)
+            @deploy_revision = File.read(revision_file).chomp
+          end
+        end
+        @deploy_revision
+      end
+
+      def self.do_cache?
+        Rails.application.config.action_controller.perform_caching
+      end
+    end
+  end
+end

data/app/helpers/sinicum/helper_utils.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+module Sinicum
+  module HelperUtils
+    DEFAULT_DOCUMENT_WORKSPACE = "dam"
+    FINGERPRINT_REGEX = /.*-[0-9a-f]{32}(\..+)?$/
+
+    protected
+
+    def object_from_key_or_object(key_or_object, workspace = nil)
+      mgnl_object_instance_cache(key_or_object, workspace) do
+        object = nil
+        if key_or_object.is_a?(Sinicum::Jcr::Node)
+          object = key_or_object
+        elsif key_or_object.is_a?(Symbol)
+          object = value_from_content(Content::Aggregator.content_data, key_or_object)
+          if Util.is_a_uuid?(object) && workspace
+            object = Jcr::Node.find_by_uuid(workspace, object)
+          end
+        elsif Util.is_a_uuid?(key_or_object)
+          node = Jcr::Node.find_by_uuid(workspace, key_or_object)
+          object = node if node
+        end
+        object
+      end
+    end
+
+    def mgnl_object_instance_cache(key_or_object, workspace, &block)
+      cache_key = [mgnl_content_data, key_or_object, workspace]
+      @__instance_cache ||= {}
+      unless @__instance_cache.key?(cache_key)
+        result = block.call
+        @__instance_cache[cache_key] = result
+      end
+      @__instance_cache[cache_key]
+    end
+
+    def value_from_content(content_data, key)
+      value = nil
+      if content_data && content_data.respond_to?(key)
+        value = content_data.send(key)
+      elsif content_data && content_data.respond_to?(:[])
+        value = content_data[key]
+      end
+      value
+    end
+
+    def meta_tag_value(key)
+      if key && instance_variable_defined?("@#{key}")
+        meta_value = instance_variable_get("@#{key}")
+        if meta_value.is_a?(String)
+          strip_tags(meta_value)
+        else
+          meta_value
+        end
+      elsif key && value_from_content(mgnl_content_data, key)
+        mgnl_out(key, format: :strip_tags)
+      else
+        nil
+      end
+    end
+
+    def meta_content_tag(options)
+      content_tag(:title) do
+        cms_title = nil
+        if defined?(@meta_title) && @meta_title
+          cms_title = @meta_title
+        elsif defined?(@page_title) && @page_title
+          cms_title = @page_title
+        else
+          cms_title = mgnl_out(:meta_title, format: :strip_tags).presence ||
+            mgnl_out(:title, format: :strip_tags)
+        end
+        aggregated_title(cms_title, options)
+      end
+    end
+
+    def aggregated_title(cms_title, options)
+      title = ""
+      title_delimiter = options[:title_delimiter] || " – "
+      title << options[:title_prefix] if options[:title_prefix].present?
+      if cms_title.present?
+        title << title_delimiter if options[:title_prefix].present?
+        title << cms_title
+        title << title_delimiter if options[:title_suffix].present?
+      end
+      title << options[:title_suffix] if options[:title_suffix].present?
+      title
+    end
+
+    def meta_simple_meta_tag(attribute_name, key)
+      result = nil
+      meta_value = key
+      meta_value = meta_tag_value(key) if key.is_a?(Symbol)
+      if meta_value.present?
+        result = tag(:meta, name: attribute_name, content: meta_value)
+        result << "\n"
+      end
+      result
+    end
+
+    def add_missing_attributes(attributes, options)
+      options.each do |key, value|
+        attributes[key.to_sym] = value unless attributes.key?(key.to_sym)
+      end
+    end
+
+    def image_attributes(image, options)
+      attributes = {}
+      attributes[:src] = adjust_to_asset_host(image.path(converter: options[:renderer]))
+      attributes[:alt] = image[:subject].present? ? image[:subject] : ""
+      [:width, :height].each do |key|
+        if options[key]
+          attributes[key] = options[key]
+        elsif options[key] != false && image.respond_to?(key)
+          attributes[key] = image.send key, options[:renderer].presence || nil
+        end
+      end
+      attributes
+    end
+
+    def link_tag_params(object, options)
+      if object.respond_to?(:path)
+        uri = object.path.gsub(%r{^/website/}, "/")
+      else
+        uri = object
+      end
+      uri = options[:prefix] + uri if options[:prefix]
+      tag_params = { href: uri }
+      tag_params[:class] = options[:class] if options[:class]
+      tag_params[:style] = options[:style] if options[:style]
+      tag_params[:target] = options[:target] if options[:target]
+      tag_params
+    end
+
+    def adjust_to_asset_host(path)
+      asset_host = defined?(compute_asset_host) ? compute_asset_host(path) : nil
+      if asset_host.nil? || !fingerprint_in_asset_path(path)
+        path
+      else
+        "#{asset_host}#{path}"
+      end
+    end
+
+    def fingerprint_in_asset_path(path)
+      !!(path && path =~ FINGERPRINT_REGEX)
+    end
+
+    def workspace(options)
+      options[:workspace] || DEFAULT_DOCUMENT_WORKSPACE
+    end
+  end
+end

data/app/helpers/sinicum/mgnl_helper.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+module Sinicum
+  module MgnlHelper
+    include HelperUtils
+    
+    # Public: Returns the path for an object:
+    #
+    # - If the object is a Node, it returns the path of the node
+    # - If the object is a UUID-String, it is resolved to the Node and the node's path
+    #   is returned
+    def mgnl_path(key_or_object, options = {})
+      path = nil
+      object = object_from_key_or_object(key_or_object, options[:workspace] || "website")
+      if object
+        if object.respond_to?(:path)
+          path = object.path
+          path = object.path(converter: options[:renderer]) if options.key?(:renderer)
+        elsif object.is_a?(String)
+          path = object.dup
+        end
+      elsif key_or_object.is_a?(String)
+        path = key_or_object.dup
+      end
+      path
+    end
+
+    def mgnl_link(key_or_object, options = {}, &block)
+      options = options.dup
+      object = object_from_key_or_object(key_or_object, options[:workspace] || "website")
+      object = key_or_object if object.nil? && key_or_object.is_a?(String)
+      if object
+        tag_params = link_tag_params(object, options)
+        if block_given?
+          content_tag(:a, tag_params) do
+            capture(&block)
+          end
+        else
+          content_tag(:a, nil, tag_params)
+        end
+      elsif block && options[:show_content]
+        capture(&block)
+      end
+    end
+
+    def mgnl_exists?(key_or_object, options = {})
+      object = object_from_key_or_object(key_or_object, options[:workspace] || "website")
+      !object.nil?
+    end
+
+    def mgnl_push(key_or_object, options = {})
+      workspace = options[:workspace]
+      pushed_content = object_from_key_or_object(key_or_object, workspace)
+      if pushed_content
+        Content::Aggregator.push(pushed_content) do
+          yield
+        end
+      end
+      nil
+    end
+
+    def mgnl_content_data
+      Content::Aggregator.content_data
+    end
+
+    def mgnl_original_content
+      Content::Aggregator.original_content
+    end
+
+    def mgnl_value(key)
+      value_from_content(Content::Aggregator.content_data, key)
+    end
+
+    def mgnl_out(key, options = {})
+      value = mgnl_value(key)
+      value = "" if value.nil?
+      value = value.to_s
+      if options[:format] == :sanitize
+        value = sanitize(value)
+      elsif options[:format] == :strip_tags
+        value = strip_tags(value)
+      end
+      value.html_safe
+    end
+
+    # Public: Displays the `<title>` tag and the `<meta>` tags for a page. The attributes
+    # must follow the default naming conventions.
+    #
+    # Currently used attributes:
+    #
+    # * title
+    # * meta_title
+    # * meta_description
+    # * meta_keywords
+    # * meta_noindex
+    # * meta_search_weight
+    # * meta_search_boost
+    #
+    # Returns a String with all necessary `<meta>` tags and the `<title>` tag.
+    def mgnl_meta(options = {})
+      result = tag(
+        :meta, :'http-equiv' => 'content-type', 'content' => 'text/html; charset=utf-8')
+      result << "\n"
+      result << meta_content_tag(options)
+      result << "\n"
+      result << meta_simple_meta_tag(:description, :meta_description)
+      result << meta_simple_meta_tag(:keywords, :meta_keywords)
+      result << meta_simple_meta_tag(:'X-Search-Weight', :meta_keywords)
+      result << meta_simple_meta_tag(:'X-Search-Boost', :meta_search_boost)
+      if meta_tag_value(:meta_noindex) || meta_tag_value(:robots) == 'false'
+        result << meta_simple_meta_tag(:robots, 'noindex, nofollow')
+      end
+      result << meta_simple_meta_tag(:language, I18n.locale.to_s)
+      result << meta_simple_meta_tag(:'DC.language', I18n.locale.to_s)
+      result.html_safe
+    end
+
+    # Public: Iterates over an array with NavigationElement instances.
+    #
+    # base_node_or_path - The node or the path that should be the base of the
+    #                     navigation
+    # type              - Type of the navigation. Currently supports only
+    #                     `:children`.
+    # options           - Options for the navigation:
+    #                     :depth - The depth of a `children` based navigation.
+    # block             - The block with the content of the navigation. It
+    #                     yields with an instance of a NavigationElement.
+    def mgnl_navigation(base_node_or_path, type, options = {}, &block)
+      elements = []
+      if type == :children
+        handler = Navigation::NavigationHandler.children(base_node_or_path, options[:depth])
+        elements = handler.elements
+      elsif type == :parents
+        handler = Navigation::NavigationHandler.parents(base_node_or_path)
+        elements = handler.elements
+      end
+      if block_given?
+        elements.each do |element, status|
+          block.call(element, status)
+        end
+      else
+        elements
+      end
+    end
+  end
+end

data/app/helpers/sinicum/mgnl_helper5.rb

@@ -0,0 +1,7 @@
+module Sinicum
+  module MgnlHelper5
+    include MgnlHelper
+    include MgnlImageHelper
+    include TaglibHelper5
+  end
+end

data/app/helpers/sinicum/mgnl_image_helper.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Sinicum
+  module MgnlImageHelper
+    include HelperUtils
+
+    def mgnl_asset_path(key_or_object = nil, options = {})
+      options[:workspace] = "dam"
+      mgnl_path(key_or_object, options)
+    end
+    
+    def mgnl_img(key_or_object, options = {})
+      image = object_from_key_or_object(key_or_object, workspace(options))
+      result = nil
+      if image
+        options = options.dup
+        attributes = image_attributes(image, options)
+        [:workspace, :renderer, :width, :height, :src, :alt].each do |attribute|
+          options.delete(attribute)
+        end
+        add_missing_attributes(attributes, options)
+        result = tag("img", attributes)
+      end
+      result
+    end
+  end
+end

data/app/helpers/sinicum/taglib_helper5.rb

@@ -0,0 +1,166 @@
+module Sinicum
+  module TaglibHelper5
+    include Templating::TemplatingUtils
+
+    def mgnl_init
+      return unless mgnl_render_bars
+      result = "<!-- begin js and css added by @cms.init -->\n"
+      result << content_tag(:meta, nil, name: "gwt:property", content: "locale=en") + "\n"
+      result << comment_tag(
+        :'cms:page',
+        nil,
+        content: component_path(mgnl_original_content.jcr_workspace, mgnl_original_content.path),
+        dialog: dialog_for_node(mgnl_original_content),
+        preview: mgnl_preview_mode)
+      result << "\n"
+
+      result << "<!-- end js and css added by @cms.init -->"
+
+      result.html_safe
+    end
+
+    def mgnl_area(name, options = {})
+      area_name = name
+      result = nil
+      if area_name.present?
+        available_components = initialize_area(mgnl_content_data, area_name)
+        if available_components
+          result = mgnl_comment_tag(
+            :'cms:area',
+            content: "#{mgnl_content_data.jcr_workspace}:#{mgnl_content_data.jcr_path}/" \
+            "#{area_name}",
+            name: area_name,
+            availableComponents: available_components.join(","),
+            type: "list",
+            label: area_name,
+            inherit: "false",
+            optional: "false",
+            showAddButton: "true",
+            showNewComponentArea: "true",
+            description: area_name) do
+            mgnl_render_component(area_name.to_sym, options)
+          end
+          result = result.html_safe if result
+        elsif !mgnl_render_bars
+          result = mgnl_render_component(area_name.to_sym, options)
+        end
+      end
+      result
+    end
+
+    def mgnl_components
+      mgnl_content_data.children
+    end
+
+    def mgnl_render_component(key_or_object, options = {})
+      result = nil
+      node = object_from_key_or_object(key_or_object)
+      if node
+        mgnl_push(node) do
+          if node.jcr_primary_type == "mgnl:component" && mgnl_render_bars
+            result = mgnl_comment_tag(
+              :'cms:component',
+              content: "#{node.jcr_workspace}:#{node.jcr_path}",
+              dialog: dialog_for_node(node),
+              label: node.mgnl_template) do
+              begin
+                render create_render_params(node, options)
+              rescue ActionView::MissingTemplate => e
+                render_missing_template(node, e)
+              end
+            end
+            result = result.html_safe
+          else
+            begin
+              result = render create_render_params(node, options)
+            rescue ActionView::MissingTemplate => e
+              result = render_missing_template(node, e)
+            end
+          end
+        end
+      end
+      result
+    end
+
+    def mgnl_render_bars
+      request.headers["HTTP_X_MGNL_ADMIN"].present? && !Rails.env.production?
+    end
+
+    def mgnl_preview_mode
+      request.headers["HTTP_X_MGNL_PREVIEW"] == "true" || !mgnl_render_bars
+    end
+
+    private
+
+    def render_missing_template(node, error)
+      type = node.jcr_primary_type == "mgnl:area" ? "area" : "component"
+      unless Rails.env.production?
+        content_tag(:div, nil, class: "mgnl-missing-template-error") do
+          content_tag(:p, nil, class: "mgnl-message") do
+            "Missing partial for #{type} ".html_safe +
+            content_tag(:code) do
+              node.mgnl_template.presence || node.jcr_name
+            end + "."
+          end
+        end
+      end
+    end
+
+    def create_render_params(node, options)
+      params = { partial: partial_name_for_node(node) }
+      params[:locals] = options[:locals] if options.key?(:locals)
+      params
+    end
+
+    def partial_name_for_node(node)
+      partial_name = nil
+      if node
+        if node.mgnl_template
+          partial_name = node.mgnl_template.gsub(":", "/")
+        elsif node.jcr_primary_type == "mgnl:area"
+          partial_name = "areas/#{node.jcr_name}"
+        end
+      end
+      partial_name = "mgnl/" + partial_name if partial_name
+      partial_name
+    end
+
+    def dialog_for_node(node)
+      @dialog_resolver ||= Templating::DialogResolver.new
+      @dialog_resolver.dialog_for_node(node)
+    end
+
+    def comment_tag(name, content_or_options_with_block = nil, options = nil, escape = true, &block)
+      result = content_tag(name, content_or_options_with_block, options, escape, &block)
+      result.gsub!("<", "<!-- ")
+      result.gsub!(">", " -->\n")
+      result
+    end
+
+    def initialize_area(base_node, area_name)
+      if mgnl_render_bars
+        @area_handler ||= Templating::AreaHandler.new
+        @area_handler.lookup_or_create_area(base_node, area_name)
+      end
+    end
+
+    def mgnl_comment_tag(tag, options = {}, &block)
+      return yield if mgnl_preview_mode
+      result = "<!-- "
+      result << tag.to_s
+      options.each do |key, value|
+        result << " #{escape_once(key.to_s)}=\"#{escape_once(value.to_s)}\""
+      end
+      result << " -->\n"
+      if block_given?
+        yield_result = yield
+        result << yield_result if yield_result.present?
+      end
+      result << "\n<!-- /#{tag} -->"
+    end
+
+    def component_path(component, path)
+      "#{component}:#{path}"
+    end
+  end
+end