alchemy_cms 2.4.beta2 → 2.4.rc1

data/app/controllers/alchemy/base_controller.rb

@@ -125,33 +125,19 @@ module Alchemy
       end
     end
 
-    # Handles the layout rendering
+    # Returns the layout to be used by the current page. This method is being
+    # used in PageController#show's invocation of #render.
     #
-    # Can be used inside the controller´s +layout+ class method
-    #
-    # === Example:
-    #   layout :layout_for_page
-    #
-    # === Usage:
-    # 1. You can pass none or false as url parameter to avoid any layout rendering.
-    # 2. You can pass a layout name of any existing layout file in +app/views/layouts+ folder.
-    #
-    # If no layout name is given, Alchemy tries to render +app/views/layouts/application/+ layout.
-    # If that is not present, Alchemy tries to render +app/views/layouts/alchemy/pages+ layout.
+    # It allows you to request a specific page layout by passing a 'layout' parameter
+    # in a request. If this parameter is set to 'none' or 'false', no layout whatsoever
+    # will be used to render the page; otherwise, a layout by the given name
+    # will be applied.
     #
     def layout_for_page
       if params[:layout] == 'none' || params[:layout] == 'false'
         false
-      elsif !params[:layout].blank?
-        if File.exist?(Rails.root.join('app/views/layouts', "#{params[:layout]}.html.erb"))
-          params[:layout]
-        else
-          raise_not_found_error
-        end
-      elsif File.exist?(Rails.root.join('app/views/layouts', 'application.html.erb'))
-        'application'
       else
-        'alchemy/pages'
+        params[:layout] || 'application'
       end
     end
 
@@ -159,8 +145,7 @@ module Alchemy
       if exception
         logger.info "Rendering 404: #{exception.message}"
       end
-      @page = Page.language_root_for(session[:language_id])
-      render :file => Rails.root.join("public/404.html"), :status => 404, :layout => !@page.nil?
+      render :file => Rails.root.join("public/404.html"), :status => 404, :layout => false
     end
 
     # Enforce ssl for login and all admin modules.

data/app/controllers/alchemy/pages_controller.rb

@@ -53,7 +53,7 @@ module Alchemy
       end
     end
 
-    protected
+  private
 
     def load_page
       # we need this, because of a dec_auth bug (it calls this method after the before_filter again).
@@ -136,25 +136,12 @@ module Alchemy
       end
     end
 
-    def find_first_public(page)
-      if page.public == true
-        return page
-      end
-      page.children.each do |child|
-        result = find_first_public(child)
-        if result != nil
-          return result
-        end
-      end
-      return nil
-    end
-
     def redirect_to_public_child
-      @page = find_first_public(@page)
-      if @page.blank?
-        raise_not_found_error
-      else
+      @page = @page.self_and_descendants.published.not_restricted.first
+      if @page
         redirect_page
+      else
+        raise_not_found_error
       end
     end
 

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

@@ -292,7 +292,7 @@ module Alchemy
         if content_for?(:title)
           title = content_for(:title)
         else
-          title = t(controller_name, :scope => :libraries)
+          title = t(controller_name, :scope => :modules)
         end
         "Alchemy CMS - #{title}"
       end

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

@@ -3,6 +3,7 @@ module Alchemy
     module ElementsHelper
 
       include Alchemy::ElementsHelper
+      include Alchemy::ElementsBlockHelper
       include Alchemy::Admin::BaseHelper
       include Alchemy::Admin::ContentsHelper
       include Alchemy::Admin::EssencesHelper

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 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 => lambda { |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)
+      end
+    end
+  end
+end

data/app/helpers/alchemy/elements_helper.rb

@@ -160,10 +160,15 @@ module Alchemy
       "#{element.name}_#{element.id}".html_safe
     end
 
-    # Renders the data-alchemy-element HTML attribut used for the preview window hover effect.
+    # Renders the HTML tag attributes required for preview mode.
     def element_preview_code(element)
-      return "" if element.nil?
-      " data-alchemy-element='#{element.id}'".html_safe if @preview_mode && element.page == @page
+      tag_options(element_preview_code_attributes(element))
+    end
+
+    # Returns a hash containing the HTML tag attributes required for preview mode.
+    def element_preview_code_attributes(element)
+      return {} unless element.present? && @preview_mode && element.page == @page
+      { :'data-alchemy-element' => element.id }
     end
 
     # Returns the full url containing host, page and anchor for the given element
@@ -171,5 +176,38 @@ module Alchemy
       "#{current_server}/#{element.page.urlname}##{element_dom_id(element)}"
     end
 
+    # Returns the element's tags information as a string. Parameters and options
+    # are equivalent to {#element_tags_attributes}.
+    #
+    # @see #element_tags_attributes
+    #
+    # @return [String]
+    #   HTML tag attributes containing the element's tag information.
+    #
+    def element_tags(element, options = {})
+      tag_options(element_tags_attributes(element, options))
+    end
+
+
+    # Returns the element's tags information as an attribute hash.
+    #
+    # @param [Alchemy::Element] element The element.
+    #
+    # @option options [Proc] :formatter
+    #   ('lambda { |tags| tags.join(' ') }')
+    #   Lambda converting array of tags to a string.
+    #
+    # @return [Hash]
+    #   HTML tag attributes containing the element's tag information.
+    #
+    def element_tags_attributes(element, options = {})
+      options = {
+        formatter: lambda { |tags| tags.join(' ') }
+      }.merge(options)
+
+      return {} if !element.taggable? || element.tag_list.blank?
+      { :'data-element-tags' => options[:formatter].call(element.tag_list) }
+    end
+
   end
 end

data/app/helpers/alchemy/pages_helper.rb

@@ -3,6 +3,7 @@ module Alchemy
 
     include Alchemy::BaseHelper
     include Alchemy::ElementsHelper
+    include Alchemy::ElementsBlockHelper
     include Alchemy::UrlHelper
 
     def render_classes(classes=[])
@@ -478,7 +479,7 @@ module Alchemy
               Alchemy.loadAlchemyMenuBar({
                 page_id: #{@page.id},
                 route: '#{Alchemy.mount_point}',
-                locale: '#{current_user.language}'
+                locale: '#{current_user.language || ::I18n.default_locale}'
               });
             } catch(e) {
               if(console){console.log(e)}

data/app/models/alchemy/attachment.rb

@@ -6,10 +6,11 @@ module Alchemy
     has_many :elements, :through => :contents
     has_many :pages, :through => :elements
 
-    attr_accessible :uploaded_data, :name, :filename
+    attr_accessible :uploaded_data, :name, :filename, :tag_list
 
     stampable(:stamper_class_name => 'Alchemy::User')
 
+    acts_as_taggable
     has_attachment(
       :storage => :file_system,
       :file_system_path => 'uploads/attachments',

data/app/models/alchemy/element.rb

@@ -1,7 +1,10 @@
 module Alchemy
   class Element < ActiveRecord::Base
 
-    FORBIDDEN_DEFINITION_ATTRIBUTES = %w(contents available_contents display_name amount picture_gallery)
+    FORBIDDEN_DEFINITION_ATTRIBUTES = %w(contents available_contents amount picture_gallery taggable)
+    SKIPPED_ATTRIBUTES_ON_COPY = %w(id position folded created_at updated_at creator_id updater_id cached_tag_list)
+
+    acts_as_taggable
 
     attr_accessible(
       :cell_id,
@@ -11,6 +14,7 @@ module Alchemy
       :page_id,
       :position,
       :public,
+      :tag_list,
       :unique
     )
 
@@ -149,15 +153,9 @@ module Alchemy
       #   @copy.public? # => false
       #
       def copy(source, differences = {})
-        attributes = source.attributes.except(
-          "id",
-          "position",
-          "folded",
-          "created_at",
-          "updated_at",
-          "creator_id",
-          "updater_id"
-        ).merge(differences.stringify_keys)
+        source.attributes.stringify_keys!
+        differences.stringify_keys!
+        attributes = source.attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY).merge(differences)
         element = self.create!(attributes.merge(:create_contents_after_create => false))
         source.contents.each do |content|
           new_content = Content.copy(content, :element_id => element.id)
@@ -506,6 +504,11 @@ module Alchemy
       page.restricted?
     end
 
+    # Returns true if the definition of this element has a taggable true value.
+    def taggable?
+      description['taggable'] == true
+    end
+
   private
 
     # creates the contents for this element as described in the elements.yml

data/app/models/alchemy/essence_link.rb

@@ -0,0 +1,11 @@
+module Alchemy
+  class EssenceLink < ActiveRecord::Base
+
+    acts_as_essence(
+      :ingredient_column => :link
+    )
+
+    attr_accessible :link, :link_title, :link_class_name, :link_target
+
+  end
+end

data/app/models/alchemy/essence_picture.rb

@@ -22,13 +22,24 @@ module Alchemy
     )
 
     belongs_to :picture
+    before_save :fix_crop_values
     before_save :replace_newlines
-    before_save :fix_crop_from
 
-    private
+  private
 
-    def fix_crop_from
-      write_attribute(:crop_from, self.crop_from.to_s.split('x').map { |number| number.to_i < 0 ? "0" : number }.join('x'))
+    def fix_crop_values
+      %w(crop_from crop_size).each do |crop_value|
+        write_attribute crop_value, normalize_crop_value(crop_value)
+      end
+    end
+
+    def normalize_crop_value(crop_value)
+      self.send(crop_value).to_s.split('x').map { |n| normalize_number(n) }.join('x')
+    end
+
+    def normalize_number(number)
+      number = number.to_f.round
+      number < 0 ? 0 : number
     end
 
     def replace_newlines