infopark_fiona_connector 7.0.1.5.2.3.rc7

data/app/helpers/rails_connector/cms_tag_helper.rb

@@ -0,0 +1,4 @@
+module RailsConnector
+  module CmsTagHelper
+  end
+end

data/app/helpers/rails_connector/default_cms_helper.rb

@@ -0,0 +1,21 @@
+module RailsConnector
+  # This is a wrapper module for the default set of Rails Connector helper modules.
+  #
+  # To make autoloading from +CmsController+ work, this module must be wrapped
+  # by a module named +CmsHelper+:
+  #
+  #   module CmsHelper
+  #     include RailsConnector::DefaultCmsHelper
+  #   end
+  # @api public
+  module DefaultCmsHelper
+    include DisplayHelper
+    include MarkerHelper
+    include CmsAssetHelper
+    include RailsConnector::CmsAssetHelper
+    include RailsConnector::TableOfContentsHelper
+    include RailsConnector::EditingHelper
+    include RailsConnector::LayoutHelper
+    include RailsConnector::CmsTagHelper
+  end
+end

data/app/helpers/rails_connector/default_cms_routing_helper.rb

@@ -0,0 +1,119 @@
+module RailsConnector
+  # @api public
+  module DefaultCmsRoutingHelper
+    # Returns the path for +target+ using the +CmsController+ routes.
+    # +target+ can be an +Obj+ or a +Link+ or a +LinkList+.
+    # If +target+ is a +Linklist+, it must be non-empty. The first +Link+ from the +LinkList+ will be used.
+    # +options+ are optional and include url settings such as path parameters or protocol.
+    # @return [String]
+    # @api public
+    def cms_path(target, options = {})
+      cms_path_or_url(target, "path", options)
+    end
+
+    # Returns the absolute URL for target using the +CmsController+ routes.
+    # +target+ can be an +Obj+ or a +Link+ or a +LinkList+.
+    # If +target+ is a +Linklist+, it must be non-empty. The first +Link+ from the +LinkList+ will be used.
+    # +options+ are optional and include url settings such as path parameters or protocol.
+    # @return [String]
+    # @api public
+    def cms_url(target, options = {})
+      cms_path_or_url(target, "url", options)
+    end
+
+    LINK_TO_UNREACHABLE = "#__target_object_not_reachable".freeze
+    LINK_TO_EMPTY_LINKLIST = "#__empty_linklist".freeze
+
+    def cms_path_or_url(target, path_or_url, options = {})
+      if target.is_a?(Link)
+        cms_path_or_url_for_links(target, path_or_url, options)
+      elsif target.is_a?(Obj)
+        cms_path_or_url_for_objs(target, path_or_url, options)
+      elsif target.respond_to?(:first)
+        if target.first.is_a?(Link)
+          cms_path_or_url_for_links(target.first, path_or_url, options)
+        else
+          LINK_TO_EMPTY_LINKLIST
+        end
+      else
+        raise "cms_path or cms_url was called with an instance of #{target.class}. " +
+              "It must only be called with an Obj or a Link or a non-empty LinkList."
+      end
+    end
+
+    def cms_path_or_url_for_links(link, path_or_url, options = {})
+      return LINK_TO_UNREACHABLE if link.internal? && link.destination_object.nil?
+
+      url = basic_url_or_path_for_link(link, path_or_url, options)
+      url = append_search(url, link) if options.empty?
+
+      append_fragment(url, link)
+    end
+
+    def cms_path_or_url_for_objs(obj, path_or_url, options = {})
+      permalink = obj.permalink
+      ignore_body_data_url = options.delete(:ignore_body_data_url)
+      if permalink && !Configuration.editor_interface_enabled?
+        __send__("cms_permalink_#{path_or_url}", options.merge(permalink: permalink))
+      elsif obj.homepage? && !Configuration.editor_interface_enabled?
+        __send__("root_#{path_or_url}", options)
+      else
+        if obj.body_data_url && !ignore_body_data_url
+          enforce_protocol_from_request(obj.body_data_url)
+        elsif obj.binary? && !obj.file_extension.blank?
+          __send__("cms_id_#{path_or_url}",
+                   options.merge(id: obj.id, slug: obj.slug.presence, format: obj.file_extension))
+        else
+          routing_options = options.merge(id: obj.id, slug: obj.slug.presence)
+          __send__("cms_id_#{path_or_url}", routing_options)
+        end
+      end
+    end
+
+    private
+
+    def basic_url_or_path_for_link(link, path_or_url, options = {})
+      if link.internal?
+        __send__("cms_#{path_or_url}", link.destination_object, options)
+      else
+        url = if link.external_prefix?
+                remove_external_prefix(link.url)
+              else
+                link.url
+              end
+
+        options.delete(:ignore_body_data_url)
+        url = merge_options(url, options) if options.any?
+        url
+      end
+    end
+
+    def remove_external_prefix(link)
+      link.gsub(/external:/, "").strip
+    end
+
+    def append_search(url, link)
+      url += "?#{link.search}" unless link.search.blank?
+      url
+    end
+
+    def append_fragment(url, link)
+      url += "##{link.fragment}" unless link.fragment.blank?
+      url
+    end
+
+    def merge_options(url, options)
+      parsed_url = URI.parse(url)
+
+      search = Rack::Utils.parse_query(parsed_url.query)
+      merged_search = search.merge(options.stringify_keys)
+      parsed_url.query = merged_search.to_query
+
+      parsed_url.to_s
+    end
+
+    def enforce_protocol_from_request(url)
+      request.ssl? && !url.starts_with?("https") ? url.gsub(/^http/, "https") : url
+    end
+  end
+end

data/app/helpers/rails_connector/display_helper.rb

@@ -0,0 +1,124 @@
+module RailsConnector
+  # This module contains a helper that can be used to render attributes of the CMS models.
+  # @api public
+  module DisplayHelper
+    # For a consistent look of your site and easy maintenance, only the display helpers
+    # should be used to render an attribute <em>value</em> of a CMS model.
+    #
+    #   <%= display_value @obj.title %>
+    # Renders the value, taking its type into account.
+    # * An HtmlString will be exported by converting its links
+    # * A Time will be exported in an international form: Year-Month-Day Hour:Minutes
+    # * A non-HTML String will be quoted
+    # * other values will be rendered unchanged
+    #
+    # @api public
+    def display_value(value)
+      case value
+      when MarkdownString then markdown(convert_links(value)).html_safe
+      when HtmlString then convert_links(value).html_safe
+      when String then html_escape_once(value).html_safe
+      when Time then html_escape_once(l(value)).html_safe
+      else value
+      end
+    end
+
+    def display_original_value(value)
+      case value
+      when HtmlString then convert_links(value, ignore_body_data_url: true).html_safe
+      else display_value(value)
+      end
+    end
+
+    # Renders a field from the CMS, including an edit marker for the preview
+    # If the option :marker is +false+, no edit marker will be rendered.
+    #
+    # <%= display_field @obj, :title %>
+    #
+    # When creating an edit marker, all options except :marker are passed to {MarkerHelper#edit_marker}.
+    #
+    # @api public
+    def display_field(obj, attr, options = {})
+      options.reverse_merge!({
+                               marker: !%i(id path created last_changed version).include?(attr.to_sym)
+                             })
+      if options.delete :marker
+        edit_marker(obj, attr, options) do |obj, attr|
+          display_value obj[attr]
+        end
+      else
+        display_value obj[attr]
+      end
+    end
+
+    # Legacy method - deprecated
+    #
+    # Use display_value and display_field instead
+    def display(*args)
+      options = if args.last.is_a? Hash
+                  args.pop
+                else
+                  {}
+                end
+      return display_value(args.first) if args.size == 1
+
+      display_field(args[0], args[1], options)
+    end
+
+    private
+
+    def markdown(string)
+      require "maruku"
+      Maruku.new(string).to_html
+    end
+
+    LINK_PATTERN = '<?\binternallink:(\d+)\b>?'.freeze
+    LINK_EXPRESSION = /#{LINK_PATTERN}/.freeze
+
+    def convert_links(content_attribute, cms_path_options = {})
+      return content_attribute unless content_attribute =~ LINK_EXPRESSION
+
+      link_map = content_attribute.source.text_links.each_with_object({}) do |link, map|
+        map[link.id.to_s] = link
+      end
+      content_attribute.gsub(/#{LINK_PATTERN}(['"]?)/) do
+        link = link_map[Regexp.last_match(1).to_s]
+        if link.blank?
+          "#{CmsRoutingHelper::LINK_TO_UNREACHABLE}#{Regexp.last_match(2)}"
+        else
+          uri = "#{cms_path(link, cms_path_options)}#{Regexp.last_match(2)}"
+          if link.markdown?
+            markdown_link(link, uri)
+          else
+            html_link(link, uri)
+          end
+        end
+      end
+    end
+
+    def html_link(link, uri)
+      subst = uri
+      name, value =
+        case link.tag_name
+        when "img", "input"
+          ["alt", link.title || ""]
+        when "a", "link"
+          ["title", begin link.title unless link.title.blank? end]
+        end
+      subst << %( #{name}="#{html_escape_once(value)}") if value
+      subst << %( target="#{html_escape_once(link.target)}") unless link.target.blank?
+      subst
+    end
+
+    def markdown_link(link, uri)
+      subst = "<#{uri}>"
+      unless link.title.blank?
+        case link.markdown_type
+        when "inline", "reference"
+          subst << %( "#{html_escape_once(link.title)}")
+        end
+      end
+      subst
+    end
+  end
+end

data/app/helpers/rails_connector/editing_helper.rb

@@ -0,0 +1,7 @@
+module RailsConnector
+  module EditingHelper
+    def include_editing_stylesheet; end
+
+    def include_editing_javascript; end
+  end
+end

data/app/helpers/rails_connector/layout_helper.rb

@@ -0,0 +1,26 @@
+module RailsConnector
+  # This module contains helpers that render tags for the html head
+  # and the end of the html body.
+  # @api public
+  module LayoutHelper
+    # Renders all tags needed in the html head.
+    # @api public
+    def rails_connector_header_tags
+      html = "".html_safe
+      html += tag("meta", name: "generator",
+                          content: "Rails Connector for Infopark CMS Fiona by Infopark AG (www.infopark.de)")
+      html += include_edit_marker_support
+      html += include_editing_stylesheet
+      html
+    end
+
+    # Renders all tags needed at the end of the body tag.
+    # @api public
+    def rails_connector_after_content_tags
+      html = "".html_safe
+      html += render_marker_code
+      html += include_editing_javascript
+      html
+    end
+  end
+end

data/app/helpers/rails_connector/marker_helper.rb

@@ -0,0 +1,371 @@
+module RailsConnector
+  # This module contains helpers that can be used to build markers for the preview.
+  #
+  # The helpers will not render anything if not in editor mode!
+  # See {RailsConnector::Configuration} for information on modes.
+  #
+  # All helpers have the following <em>options</em>, unknown options are passed
+  # to the HTML element which is being created:
+  #
+  # [:context] the context object that will be shown in the preview after editing
+  # [:size] the symbolic size of the target window to open
+  # [:target] the target frame in which the edit window is to be opened.
+  #
+  # You can specify the size of the edit window by means of the <tt>:size</tt> option:
+  #
+  # [<tt>'n'</tt>] normal browser window
+  # [<tt>'udl'</tt>] undecorated large browser window
+  # [<tt>'uds'</tt>] undecorated small browser window
+  # [<tt>'udt'</tt>] undecorated tiny browser window
+  #
+  # The <tt>:target</tt> option becomes the <tt>target</tt> attribute of the <tt><a></tt> tag.
+  # @api public
+  module MarkerHelper
+    # Renders an edit marker for a named attribute of an active object in the preview.
+    # <em>obj</em> is the Obj to edit, <em>attr</em> the attribute as a Symbol or String.
+    # The helper will render nothing if the object is inactive! The :context defaults to obj.
+    #
+    # The following code will render an edit marker for the title attribute of the current object:
+    #
+    #   <%= edit_marker @obj, :title %>
+    #
+    # By passing a block, the evaluated block will be included in the marker:
+    #   <%= edit_marker @obj, :title do |obj, attr|
+    #     display_value obj[attr]
+    #   end %>
+    #
+    # The last form is the default of {DisplayHelper#display_field} without the option <code>:marker => false</code>.
+    # When the blob evaluates to nil, an empty string or array, the markup of the option +:default_value+
+    # will be rendered.
+    #
+    # Hint: You should not render edit markers within elements that are hidden via CSS (<code>display:none</code>),
+    # otherwise they cannot be displayed correctly.
+    # @api public
+    def edit_marker(obj, attr, options = {})
+      if Configuration.editor_interface_enabled? && !session[:hide_editmarkers]
+        context = (options.delete :context) || @obj
+        default_value = options.delete(:default_value)
+
+        if block_given?
+          content = yield(obj, attr)
+          content = default_value || raw("&nbsp;") if content.blank?
+        else
+          content = attr.to_s.humanize
+          content = obj.name + ": " + content if obj != context
+        end
+
+        marker_id = store_marker_definition(
+          obj_id: obj.id,
+          attribute: format_attribute_name_for_gui(attr),
+          context_id: context ? context.id : nil,
+          size: options.delete(:size),
+          target: options.delete(:target),
+          memberships: required_memberships_for_editing(obj, attr)
+        )
+
+        store_edit_marker_markup(content_tag(:a, "",
+                                             class: "nps_edit_marker nps_marker_id_#{marker_id}"))
+
+        tag_type = options.delete(:tag) || :span
+        content_tag(
+          tag_type,
+          content.to_s,
+          options.merge(class: (options[:class]).to_s, id: "nps_marker_id_#{marker_id}")
+        )
+      else
+        block_given? ? yield(obj, attr) : nil
+      end
+    end
+
+    # Renders a link which the editor can use to toggle on/off the editmarkers shown
+    # in the preview.
+    # This link will only be shown if the Rails Connector is in <tt>editor</tt> mode.
+    # <em>value</em> the link text or e.g. an image_tag
+    # @api public
+    def toggle_edit_marker_link(value)
+      link_to value, toggle_markers_url(@obj) if Configuration.editor_interface_enabled?
+    end
+
+    # Renders a marker for an action to be performed with any number of objects.
+    # <em>action</em> the attribute as a Symbol or String.
+    # <em>objs</em> is an Array containing a single, none or more than one Obj.
+    # The helper has additional options:
+    # [:permissions] is an Array of permissions the current user needs to use
+    # the marker: :read, :write, :root, :create_children - defaults to [:read].
+    # This option is available for a single Obj passed to <em>objs</em>.
+    # [:params] a hash of parameters to be passed to the action.
+    #
+    # The following code will render an action marker for the release action of the current object:
+    #
+    #   <%= action_marker :workflow_release, [@obj] %>
+    # @api public
+    def action_marker(action, objs, options = {})
+      return unless Configuration.editor_interface_enabled?
+
+      context = (options.delete :context) || @obj
+      size = options.delete(:size)
+      target = options.delete(:target) || "_blank"
+      params = options.delete(:params)
+      permissions = options.delete(:permissions) || [:read]
+
+      memberships = if objs.size == 1
+                      required_memberships_for_permissions(objs.first, permissions)
+                    else
+                      []
+                    end
+
+      marker_id = store_marker_definition(
+        memberships: memberships
+      )
+
+      link_to(
+        block_given? ? yield : action.to_s.humanize,
+        uri_for_action_marker(action, objs, context, size, target, params),
+        options.merge(class: ["nps_action_marker", "nps_marker_id_#{marker_id}", options[:class]].compact.join(" "))
+      )
+    end
+
+    # Generates an edit marker link.
+    #
+    # [name] the link caption.
+    # [obj] the object for which the edit dialog will be generated.
+    # [attr] the attribute for which the edit dialog will be generated.
+    # [options] options for the edit dialog (see {MarkerHelper#edit_marker}).
+    # @api public
+    def link_to_edit(name, obj, attr, options = {})
+      if Configuration.editor_interface_enabled?
+        context = (options.delete :context) || @obj
+        size = options.delete(:size)
+        target = options.delete(:target) || "_blank"
+
+        link_to name.to_s, "#", onclick: "inline_editing.openEditDialog('#{obj.id}', '#{attr}', '#{context.id || "null"}', '#{size || "null"}', '#{target || "null"}'); return false;"
+      end
+    end
+
+    # Renders a folding menu which can be used to insert various edit actions or
+    # informations.
+    #
+    # [left] the left offset.
+    # [top] the top offset.
+    # [&block] the content which will be displayed in the menu.
+    #
+    # To generate a menu you have to create one using the {#marker_menu} helper.
+    # Than you have to mark the target for which the menu should be displayed
+    # using the {#marker_menu_target} helper.
+    #
+    # Usage:
+    #   <%= marker_menu do %>
+    #     Menu
+    #   <% end %>
+    #
+    #   <%= marker_menu_target(:div) do %>
+    #     Content
+    #   <% end %>
+    # @api public
+    def marker_menu(left = 0, top = 0, &block)
+      self.current_marker_menu_id = store_marker_definition(
+        offset_left: left,
+        offset_top: top
+      )
+      store_marker_markup(content_tag(
+                            :div,
+                            marker_menu_markup(capture(&block)),
+                            class: "nps_marker_menu nps_marker_id_#{current_marker_menu_id}",
+                            id: "nps_marker_menu_#{current_marker_menu_id}"
+                          ))
+      nil
+    end
+
+    # Marks the given content to display the previous defined marker menu.
+    #
+    # [tag_name] the tag in which the content will be displayed.
+    # [options] the options for the tag.
+    # [&block] the content which will be displayed with the menu.
+    #
+    # See {#marker_menu} for an example.
+    # @api public
+    def marker_menu_target(tag_name, options = {}, &block)
+      content_tag(
+        tag_name,
+        capture(&block),
+        options.merge(class: "#{marker_menu_target_class} #{options[:class]}")
+      )
+    end
+
+    # Returns the css class used for the target element where the marker menu
+    # should be displayed.
+    #
+    # Will be used automatically if you use the helpers {#marker_menu} and
+    # {#marker_menu_target}. But if you want to set a marker menu manually to
+    # an element (e.g. an image) you need to supply this css class.
+    # @api public
+    def marker_menu_target_class
+      if Configuration.editor_interface_enabled?
+        "nps_marker_menu_target nps_marker_menu_target_#{current_marker_menu_id}"
+      end
+    end
+
+    # Renders the necessary JavaScript and CSS includes to use the edit markers.
+    def include_edit_marker_support
+      if Configuration.editor_interface_enabled?
+        raw <<-EOF
+          #{stylesheet_link_tag :editmarker}
+          #{javascript_include_tag :editmarker}
+          #{content_tag(:script, type: "text/javascript") { "inline_editing.init();" }}
+        EOF
+      end
+    end
+
+    # Renders the necessary marker code to use edit markers and marker menus.
+    def render_marker_code
+      return unless Configuration.editor_interface_enabled?
+
+      html = raw("#{render_marker_definitions}\n#{render_marker_menus}\n#{render_edit_markers}")
+      reset_marker_code
+      html
+    end
+
+    # This helper method can be used in {#marker_menu} to generate a list with
+    # actions using {#edit_item} or {#action_item}. For each action a icon and
+    # title will be shown.
+    #
+    # Usage:
+    #   <%= marker_menu do %>
+    #     <%= iconlist do %>
+    #       <%= edit_item("edit title", "css_class", @obj, :image) %>
+    #       <%= action_item("edit image", "css_class", [@obj], :editImage) %>
+    #     <% end %>
+    #   <% end %>
+    # @api public
+    def iconlist(&block)
+      content_tag(:ul, capture(&block)) if block_given?
+    end
+
+    # Creates an edit marker item for the list generated by {#iconlist}.
+    #
+    # [title] the title which will be displayed.
+    # [css_class] the css-class can be used to display a different icon.
+    # [obj] the object for which the edit dialog will be generated.
+    # [attribute] the attribute for which the edit dialog will be generated.
+    # [options] options that will be delegated to the {#link_to_edit} helper.
+    # @api public
+    def edit_item(title, css_class, obj, attribute, options = {})
+      edit_link = link_to_edit(content_tag(:span, title, class: css_class), obj, attribute, options)
+      content_tag(:li, edit_link)
+    end
+
+    # Creates an action marker item for the list generated by {#iconlist}.
+    #
+    # [title] the title which will be displayed.
+    # [css_class] the css-class can be used to display a different icon.
+    # [objs] the array of objects for which the action dialog will be generated.
+    # [action] the action for which the action dialog will be generated.
+    # [options] options that will be delegated to the {#action_marker} helper.
+    # @api public
+    def action_item(title, css_class, objs, action, options = {})
+      action_link = action_marker(action, objs, options) { content_tag(:span, title, class: css_class) }
+      content_tag(:li, action_link)
+    end
+
+    private
+
+    attr_writer :current_marker_menu_id
+
+    def current_marker_menu_id
+      @current_marker_menu_id or raise "Tried to create a marker menu target before a marker menu was created!"
+    end
+
+    JS_HEADER = <<~ENDOFSTRING.freeze
+      <script type="text/javascript">
+      // <![CDATA[
+    ENDOFSTRING
+
+    JS_FOOTER = <<~ENDOFSTRING.freeze
+      // ]]>
+      </script>
+    ENDOFSTRING
+
+    def store_marker_definition(definition)
+      @marker_definitions ||= {}
+      marker_id = random_marker_id
+      @marker_definitions[marker_id] = definition
+      marker_id
+    end
+
+    def random_marker_id
+      rand(1_000_000_000)
+    end
+
+    def render_marker_definitions
+      return unless @marker_definitions.present?
+
+      "#{JS_HEADER}inline_editing.storeMarkerDefinitions(#{@marker_definitions.to_json});" +
+        JS_FOOTER.to_s
+    end
+
+    def store_marker_markup(markup)
+      @marker_markup ||= []
+      @marker_markup << markup
+    end
+
+    def store_edit_marker_markup(markup)
+      @edit_marker_markup ||= []
+      @edit_marker_markup << markup
+    end
+
+    def reset_marker_code
+      @marker_definitions = @marker_markup = @edit_marker_markup = nil
+    end
+
+    def render_marker_menus
+      (@marker_markup || []).join
+    end
+
+    def render_edit_markers
+      (@edit_marker_markup || []).join
+    end
+
+    def required_memberships_for_editing(obj, attr)
+      permissions = [:read]
+      permissions << if %i(name obj_class workflow suppressexport permalink).include?(attr.to_sym)
+                       :root
+                     else
+                       :write
+                     end
+
+      required_memberships_for_permissions(obj, permissions)
+    end
+
+    def required_memberships_for_permissions(obj, permissions)
+      permissions.map { |perm| obj.permissions.__send__(perm) }
+    end
+
+    def uri_for_action_marker(action, objects, context = nil, size = nil, target = nil, params = nil)
+      action = action.to_s
+      objectIds = objects.collect(&:id).to_json
+      contextId = context.nil? ? "null" : context.id
+      size = size.nil? ? "null" : "'#{size}'"
+      target = target.nil? ? "null" : "'#{target}'"
+      params = params.blank? ? "null" : "'#{escape_javascript(params.to_json.gsub('"', "%22"))}'"
+      "javascript:parent.openActionDialog('#{action}',#{objectIds},#{contextId},#{params},#{size},#{target})"
+    end
+
+    def format_attribute_name_for_gui(attr)
+      attr = attr.to_s
+      attr = "blob" if attr == "body"
+      attr = attr.camelize(:lower) if %w(valid_from valid_until obj_class).include? attr
+      attr
+    end
+
+    def marker_menu_markup(content)
+      raw %(<a class="nps_marker_menu_button" name="nps_marker_menu_button" href="#">MENU</a>
+      <div class="nps_marker_menu_content" style="display:none;">
+        <div class="b1"></div><div class="b2"></div><div class="b3"></div><div class="b4"></div>
+        <div class="core">
+          #{content}
+        </div>
+        <div class="b4"></div><div class="b3"></div><div class="b2"></div><div class="b1"></div>
+      </div>)
+    end
+  end
+end