lc_alchemy_cms 3.2.0

data/app/helpers/alchemy/admin/pages_helper.rb

@@ -0,0 +1,70 @@
+module Alchemy
+  module Admin
+    module PagesHelper
+      include Alchemy::BaseHelper
+
+      # Used for rendering the folder link in +Admin::Pages#index+ sitemap.
+      #
+      def sitemap_folder_link(page)
+        if page.folded?(current_alchemy_user.id)
+          css_class = 'folded'
+          title = _t('Show childpages')
+        else
+          css_class = 'collapsed'
+          title = _t('Hide childpages')
+        end
+        link_to(
+          '',
+          alchemy.fold_admin_page_path(page),
+          remote: true,
+          method: :post,
+          class: "page_folder #{css_class} spinner",
+          title: title,
+          id: "fold_button_#{page.id}"
+        )
+      end
+
+      # Returns options tags for the screen sizes select in page edit view.
+      #
+      def preview_sizes_for_select
+        options_for_select([
+          'auto',
+          [_t('240', :scope => 'preview_sizes'), 240],
+          [_t('320', :scope => 'preview_sizes'), 320],
+          [_t('480', :scope => 'preview_sizes'), 480],
+          [_t('768', :scope => 'preview_sizes'), 768],
+          [_t('1024', :scope => 'preview_sizes'), 1024],
+          [_t('1280', :scope => 'preview_sizes'), 1280]
+        ])
+      end
+
+      # Returns the translated explanation of the page´s status.
+      #
+      def combined_page_status(page)
+        page.status.map do |state, value|
+          next if state == :locked
+          val = content_tag(:span, '', class: page.send(state) ? "page_status #{state}" : "page_status not_#{state}")
+          val += page.status_title(state)
+        end.delete_if(&:blank?).join("<br>").html_safe
+      end
+
+      # Renders a label for page's page layout
+      #
+      # If the page layout description of the page is missing, it displays a warning.
+      #
+      def page_layout_label(page)
+        if page.persisted? && page.layout_description.blank?
+          [
+            content_tag(:span, '',
+              class: 'inline warning icon',
+              title: _t(:page_layout_description_missing)
+            ),
+            _t(:page_type)
+          ].join('&nbsp;').html_safe
+        else
+          _t(:page_type)
+        end
+      end
+    end
+  end
+end

data/app/helpers/alchemy/admin/pictures_helper.rb

@@ -0,0 +1,30 @@
+module Alchemy
+  module Admin
+    module PicturesHelper
+
+      def create_or_assign_url(picture_to_assign, options)
+        if @content.nil?
+          {
+            :controller => :contents,
+            :action => :create,
+            :picture_id => picture_to_assign.id,
+            :content => {
+              :essence_type => "Alchemy::EssencePicture",
+              :element_id => @element.id
+            },
+            :options => options
+          }
+        else
+          {
+            :controller => :essence_pictures,
+            :action => :assign,
+            :picture_id => picture_to_assign.id,
+            :content_id => @content.id,
+            :options => options
+          }
+        end
+      end
+
+    end
+  end
+end

data/app/helpers/alchemy/admin/tags_helper.rb

@@ -0,0 +1,102 @@
+module Alchemy
+  module Admin
+    module TagsHelper
+
+      # Renders tags list items for given class name
+      #
+      # @param class_name [String]
+      #   The class_name representing a tagged class
+      #
+      # @return [String]
+      #   A HTML string containing <tt><li></tt> tags
+      #
+      def render_tag_list(class_name, params)
+        raise ArgumentError.new('Please provide a String as class_name') if class_name.nil?
+        li_s = []
+        class_name.constantize.tag_counts.sort { |x, y| x.name.downcase <=> y.name.downcase }.each do |tag|
+          tags = filtered_by_tag?(tag) ? tag_filter(remove: tag) : tag_filter(add: tag)
+          li_s << content_tag('li', name: tag.name, class: tag_list_tag_active?(tag, params) ? 'active' : nil) do
+            link_to(
+              "#{tag.name} (#{tag.count})",
+              url_for(
+                params.delete_if { |k, v| k == "page" }.merge(
+                  action: 'index',
+                  tagged_with: tags
+                )
+              ),
+              remote: request.xhr?,
+              class: 'please_wait'
+            )
+          end
+        end
+        li_s.join.html_safe
+      end
+
+      # Returns true if the given tag is in +params[:tag_list]+
+      #
+      # @param tag [ActsAsTaggableOn::Tag]
+      #   the tag
+      # @param params [Hash]
+      #   url params
+      # @return [Boolean]
+      #
+      def tag_list_tag_active?(tag, params)
+        params[:tagged_with].to_s.split(',').include?(tag.name)
+      end
+
+      # Checks if the tagged_with param contains the given tag
+      def filtered_by_tag?(tag)
+        if params[:tagged_with].present?
+          tags = params[:tagged_with].split(',')
+          tags.include?(tag.name)
+        else
+          false
+        end
+      end
+
+      # Adds the given tag to the tag filter.
+      def add_to_tag_filter(tag)
+        if params[:tagged_with].present?
+          tags = params[:tagged_with].split(',')
+          tags << tag.name
+        else
+          [tag.name]
+        end
+      end
+
+      # Removes the given tag from the tag filter.
+      def remove_from_tag_filter(tag)
+        if params[:tagged_with].present?
+          tags = params[:tagged_with].split(',')
+          tags.delete_if { |t| t == tag.name }
+        else
+          []
+        end
+      end
+
+      # Returns the tag filter from params.
+      #
+      # A tag can be added to the filter.
+      # A tag can also be removed.
+      #
+      # Options are:
+      #   * options (Hash):
+      #   ** :add (ActsAsTaggableOn::Tag) - The tag that should be added to the tag-filter
+      #   ** :remove (ActsAsTaggableOn::Tag) - The tag that should be removed from the tag-filter
+      #
+      def tag_filter(options={})
+        case
+          when options[:add]
+            taglist = add_to_tag_filter(options[:add]) if options[:add]
+          when options[:remove]
+            taglist = remove_from_tag_filter(options[:remove]) if options[:remove]
+          else
+            return params[:tagged_with]
+        end
+        return nil if taglist.blank?
+        taglist.uniq.join(',')
+      end
+
+    end
+  end
+end

data/app/helpers/alchemy/base_helper.rb

@@ -0,0 +1,81 @@
+module Alchemy
+  module BaseHelper
+
+    def _t(key, *args)
+      I18n.t(key, *args)
+    end
+
+    # An alias for truncate.
+    # Left here for downwards compatibilty.
+    def shorten(text, length)
+      text.truncate(:length => length)
+    end
+
+    def parse_sitemap_name(page)
+      if multi_language?
+        pathname = "/#{Language.current.code}/#{page.urlname}"
+      else
+        pathname = "/#{page.urlname}"
+      end
+      pathname
+    end
+
+    # Logs a message in the Rails logger (warn level) and optionally displays an error message to the user.
+    def warning(message, text = nil)
+      Logger.warn(message, caller.first)
+      unless text.nil?
+        warning = content_tag('p', :class => 'content_editor_error') do
+          render_icon('warning') + text
+        end
+        return warning
+      end
+    end
+
+    # Returns an icon
+    def render_icon(icon_class)
+      content_tag('span', '', :class => "icon #{icon_class}")
+    end
+
+    # Returns a div with an icon and the passed content
+    # The default message type is info, but you can also pass
+    # other types like :warning or :error
+    #
+    # === Usage:
+    #
+    #   <%= render_message :warning do
+    #     <p>Caution! This is a warning!</p>
+    #   <% end %>
+    #
+    def render_message(type = :info, msg = nil, &blk)
+      if block_given?
+        content_tag :div, render_icon(type) + capture(&blk), :class => "#{type} message"
+      else
+        content_tag :div, render_icon(type) + msg, :class => "#{type} message"
+      end
+    end
+
+    # Renders the flash partial (+alchemy/admin/partials/flash+)
+    #
+    # @param [String] notice The notice you want to display
+    # @param [Symbol] style The style of this flash. Valid values are +:notice+ (default), +:warn+ and +:error+
+    #
+    def render_flash_notice(notice, style = :notice)
+      render('alchemy/admin/partials/flash', flash_type: style, message: notice)
+    end
+
+    # Checks if the given argument is a String or a Page object.
+    # If a String is given, it tries to find the page via page_layout
+    # Logs a warning if no page is given.
+    def page_or_find(page)
+      if page.is_a?(String)
+        page = Language.current.pages.find_by(page_layout: page)
+      end
+      if page.blank?
+        warning("No Page found for #{page.inspect}")
+        return
+      else
+        page
+      end
+    end
+  end
+end

data/app/helpers/alchemy/elements_block_helper.rb

@@ -0,0 +1,162 @@
+module Alchemy
+  # Provides a collection of block-level helpers, allowing for a much more
+  # concise way of writing element view/editor partials.
+  #
+  module ElementsBlockHelper
+    # Base class for our block-level helpers.
+    #
+    class BlockHelper
+      def initialize(helpers, opts = {})
+        @helpers = helpers
+        @opts = opts
+      end
+
+      def opts
+        @opts
+      end
+
+      def element
+        opts[:element]
+      end
+
+      def helpers
+        @helpers
+      end
+    end
+
+    # Block-level helper class for element views.
+    #
+    class ElementViewHelper < BlockHelper
+      # Renders one of the element's contents.
+      #
+      def render(name, *args)
+        helpers.render_essence_view_by_name(element, name.to_s, *args)
+      end
+
+      # Returns one of the element's contents (ie. essence instances).
+      #
+      def content(name)
+        element.content_by_name(name)
+      end
+
+      # Returns the ingredient of one of the element's contents.
+      #
+      def ingredient(name)
+        element.ingredient(name)
+      end
+
+      # Returns true if the given content has been filled by the user.
+      #
+      def has?(name)
+        element.has_ingredient?(name)
+      end
+
+      # Return's the given content's essence.
+      #
+      def essence(name)
+        content(name).try(:essence)
+      end
+    end
+
+    # Block-level helper class for element editors.
+    #
+    class ElementEditorHelper < BlockHelper
+      def edit(name, *args)
+        helpers.render_essence_editor_by_name(element, name.to_s, *args)
+      end
+    end
+
+    # Block-level helper for element views. Constructs a DOM element wrapping
+    # your content element and provides a block helper object you can use for
+    # concise access to Alchemy's various helpers.
+    #
+    # === Example:
+    #
+    #   <%= element_view_for(element) do |el| %>
+    #     <%= el.render :title %>
+    #     <%= el.render :body %>
+    #     <%= link_to "Go!", el.ingredient(:target_url) %>
+    #   <% end %>
+    #
+    # You can override the tag, ID and class used for the generated DOM
+    # element:
+    #
+    #   <%= element_view_for(element, tag: 'span', id: 'my_id', class: 'thing') do |el| %>
+    #      <%- ... %>
+    #   <% end %>
+    #
+    # If you don't want your view to be wrapped into an extra element, simply set
+    # `tag` to `false`:
+    #
+    #   <%= element_view_for(element, tag: false) do |el| %>
+    #      <%- ... %>
+    #   <% end %>
+    #
+    # @param [Alchemy::Element] element
+    #   The element to display.
+    # @param [Hash] options
+    #   Additional options.
+    #
+    # @option options :tag (:div)
+    #   The HTML tag to be used for the wrapping element.
+    # @option options :id (the element's dom_id)
+    #   The wrapper tag's DOM ID.
+    # @option options :class (the element's essence name)
+    #   The wrapper tag's DOM class.
+    # @option options :tags_formatter
+    #   A lambda used for formatting the element's tags (see Alchemy::ElementsHelper::element_tags_attributes). Set to +false+ to not include tags in the wrapper element.
+    #
+    def element_view_for(element, options = {})
+      options = {
+        tag: :div,
+        id: element_dom_id(element),
+        class: element.name,
+        tags_formatter: ->(tags) { tags.join(" ") }
+      }.merge(options)
+
+      # capture inner template block
+      output = capture do
+        yield ElementViewHelper.new(self, element: element) if block_given?
+      end
+
+      # wrap output in a useful DOM element
+      if tag = options.delete(:tag)
+        # add preview attributes
+        options.merge!(element_preview_code_attributes(element))
+
+        # add tags
+        if tags_formatter = options.delete(:tags_formatter)
+          options.merge!(element_tags_attributes(element, formatter: tags_formatter))
+        end
+
+        output = content_tag(tag, output, options)
+      end
+
+      # that's it!
+      output
+    end
+    # Block-level helper for element editors. Provides a block helper object
+    # you can use for concise access to Alchemy's various helpers.
+    #
+    # === Example:
+    #
+    #   <%= element_editor_for(element) do |el| %>
+    #     <%= el.edit :title %>
+    #     <%= el.edit :body %>
+    #     <%= el.edit :target_url %>
+    #   <% end %>
+    #
+    # @param [Alchemy::Element] element
+    #   The element to display.
+    #
+    def element_editor_for(element, options = {})
+      options = {
+        # nothing here yet.
+      }.merge(options)
+
+      capture do
+        yield ElementEditorHelper.new(self, element: element) if block_given?
+      end
+    end
+  end
+end