alchemy_cms 2.5.3.1 → 2.6.0.rc5

data/app/models/alchemy/page/cells.rb

@@ -0,0 +1,71 @@
+module Alchemy
+  module Page::Cells
+
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :cells, :dependent => :destroy
+      after_create :create_cells, :if => :can_have_cells?, :unless => :systempage?
+    end
+
+    module ClassMethods
+
+      # Copy page cells
+      #
+      # @param source [Alchemy::Page]
+      # @param target [Alchemy::Page]
+      # @return [Array]
+      #
+      def copy_cells(source, target)
+        new_cells = []
+        source.cells.each do |cell|
+          new_cells << Cell.create(:name => cell.name, :page_id => target.id)
+        end
+        new_cells
+      end
+
+    end
+
+    # Returns true, if the page's page_layout defines cells.
+    def can_have_cells?
+      definition['cells'].present?
+    end
+
+    # Returns true, if the page has cells.
+    def has_cells?
+      cells.any?
+    end
+
+    # Returns the cell definitions from page's page_layout defintion.
+    def cell_definitions
+      cell_names = self.layout_description['cells']
+      return [] if cell_names.blank?
+      Cell.all_definitions_for(cell_names)
+    end
+
+    # Returns elements grouped by cell.
+    def elements_grouped_by_cells
+      elements.not_trashed.in_cell.group_by(&:cell)
+    end
+
+    # Returns element names from cell definition.
+    def element_names_from_cells
+      cell_definitions.collect { |c| c['elements'] }.flatten.uniq
+    end
+
+    # Returns element names that are not defined in a cell.
+    def element_names_not_in_cell
+      layout_description['elements'].uniq - element_names_from_cells
+    end
+
+  private
+
+    # Creates cells that are defined in page's page_layout definition.
+    def create_cells
+      definition['cells'].each do |cellname|
+        cells.create!(:name => cellname)
+      end
+    end
+
+  end
+end

data/app/models/alchemy/page/elements.rb

@@ -0,0 +1,147 @@
+module Alchemy
+  module Page::Elements
+
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :do_not_autogenerate
+
+      has_many :elements, :order => :position
+      has_many :contents, :through => :elements
+      has_and_belongs_to_many :to_be_sweeped_elements, :class_name => 'Alchemy::Element', :uniq => true, :join_table => 'alchemy_elements_alchemy_pages'
+
+      after_create :autogenerate_elements, :unless => proc { systempage? || do_not_autogenerate }
+      after_update :trash_not_allowed_elements, :if => :page_layout_changed?
+      after_update :autogenerate_elements, :if => :page_layout_changed?
+      after_destroy { elements.each { |el| el.destroy unless el.trashed? } }
+    end
+
+    module ClassMethods
+
+      # Copy page elements
+      #
+      # @param source [Alchemy::Page]
+      # @param target [Alchemy::Page]
+      # @return [Array]
+      #
+      def copy_elements(source, target)
+        new_elements = []
+        source.elements.not_trashed.each do |element|
+          # detect cell for element
+          if element.cell
+            cell = target.cells.detect { |c| c.name == element.cell.name }
+          else
+            cell = nil
+          end
+          # if cell is nil also pass nil to element.cell_id
+          new_element = Element.copy(element, :page_id => target.id, :cell_id => (cell.blank? ? nil : cell.id))
+          # move element to bottom of the list
+          new_element.move_to_bottom
+          new_elements << new_element
+        end
+        new_elements
+      end
+
+    end
+
+    # Finds selected elements from page.
+    #
+    # Returns only public elements by default.
+    # Pass true as second argument to get all elements.
+    #
+    # === Options are:
+    #
+    #     :only => Array of element names    # Returns only elements with given names
+    #     :except => Array of element names  # Returns all elements except the ones with given names
+    #     :count => Integer                  # Limit the count of returned elements
+    #     :offset => Integer                 # Starts with an offset while returning elements
+    #     :random => Boolean                 # Return elements randomly shuffled
+    #     :from_cell => Cell or String       # Return elements from given cell
+    #
+    def find_selected_elements(options = {}, show_non_public = false)
+      if options[:from_cell].class.name == 'Alchemy::Cell'
+        elements = options[:from_cell].elements
+      elsif !options[:from_cell].blank? && options[:from_cell].class.name == 'String'
+        cell = cells.find_by_name(options[:from_cell])
+        if cell
+          elements = cell.elements
+        else
+          warn("Cell with name `#{options[:from_cell]}` could not be found!")
+          # Returns an empty relation. Can be removed with the release of Rails 4
+          elements = self.elements.where('1 = 0')
+        end
+      else
+        elements = self.elements.not_in_cell
+      end
+      if !options[:only].blank?
+        elements = elements.named(options[:only])
+      elsif !options[:except].blank?
+        elements = elements.excluded(options[:except])
+      end
+      elements = elements.reverse_order if options[:reverse_sort] || options[:reverse]
+      elements = elements.offset(options[:offset]).limit(options[:count])
+      elements = elements.order("RAND()") if options[:random]
+      show_non_public ? elements : elements.published
+    end
+
+    # What is this? A Kind of proxy method? Why not rendering the elements directly if you already have them????
+    def find_elements(options = {}, show_non_public = false)
+      if !options[:collection].blank? && options[:collection].is_a?(Array)
+        return options[:collection]
+      else
+        find_selected_elements(options, show_non_public)
+      end
+    end
+
+    # Returns all elements that should be feeded via rss.
+    #
+    # Define feedable elements in your +page_layouts.yml+:
+    #
+    #   - name: news
+    #     feed: true
+    #     feed_elements: [element_name, element_2_name]
+    #
+    def feed_elements
+      elements.named(definition['feed_elements'])
+    end
+
+  private
+
+    # Looks in the page_layout descripion, if there are elements to autogenerate.
+    #
+    # And if so, it generates them.
+    #
+    # If the page has cells, it looks if there are elements to generate.
+    #
+    def autogenerate_elements
+      elements_already_on_page = self.elements.available.collect(&:name)
+      elements = self.layout_description["autogenerate"]
+      if elements.present?
+        elements.each do |element|
+          next if elements_already_on_page.include?(element)
+          Element.create_from_scratch(attributes_for_element_name(element))
+        end
+      end
+    end
+
+    # Returns a hash of attributes for given element name
+    def attributes_for_element_name(element)
+      if self.has_cells? && (cell_definition = cell_definitions.detect { |c| c['elements'].include?(element) })
+        cell = self.cells.find_by_name(cell_definition['name'])
+        if cell
+          return {:page_id => self.id, :cell_id => cell.id, :name => element}
+        else
+          raise "Cell not found for page #{self.inspect}"
+        end
+      else
+        return {:page_id => self.id, :name => element}
+      end
+    end
+
+    # Trashes all elements that are not allowed for this page_layout.
+    def trash_not_allowed_elements
+      elements.select { |e| !definition['elements'].include?(e.name) }.map(&:trash)
+    end
+
+  end
+end

data/app/models/alchemy/page/naming.rb

@@ -0,0 +1,90 @@
+module Alchemy
+  module Page::Naming
+
+    extend ActiveSupport::Concern
+    include NameConversions
+    RESERVED_URLNAMES = %w(admin messages new)
+
+    included do
+      before_validation :set_urlname, :if => :renamed?, :unless => proc { systempage? || redirects_to_external? }
+
+      validates_presence_of :name
+      validates_length_of :urlname, :minimum => 3, :if => 'urlname.present?'
+      validates_uniqueness_of(
+        :urlname,
+        :scope => [:language_id, :layoutpage],
+        :if => 'urlname.present?'
+      )
+      validates :urlname, :exclusion => {:in => RESERVED_URLNAMES}
+
+      before_save :set_title, :if => 'title.blank?', :unless => proc { systempage? || redirects_to_external? }
+      after_update(:if => proc { Config.get(:url_nesting) && (urlname_changed? || visible_changed?) }) do
+        self.reload
+        self.descendants.map(&:update_urlname!)
+      end
+      after_move :update_urlname!, :if => proc { Config.get(:url_nesting) }
+    end
+
+    # Returns true if name or urlname has changed.
+    def renamed?
+      name_changed? || urlname_changed?
+    end
+
+    # Makes a slug of all ancestors urlnames including mine and delimit them be slash.
+    # So the whole path is stored as urlname in tha database.
+    def update_urlname!
+      names = ancestors.visible.contentpages.where(language_root: nil).map(&:slug).compact
+      new_urlname = (names << slug).join('/')
+      # update without callbacks
+      if new_record?
+        write_attribute :urlname, new_urlname
+      else
+        if urlname != new_urlname
+          legacy_urls.create(:urlname => urlname)
+        end
+        update_column :urlname, new_urlname
+      end
+    end
+
+    # Returns always the last part of a urlname path
+    def slug
+      urlname.to_s.split('/').last
+    end
+
+  private
+
+    # Sets the urlname to a url friendly slug.
+    # Either from name, or if present, from urlname.
+    # If url_nesting is enabled the urlname contains the whole path.
+    def set_urlname
+      if Config.get(:url_nesting)
+        url_name = [
+          parent.nil? || parent.language_root? ? nil : parent.urlname,
+          convert_url_name((urlname.blank? ? name : slug))
+        ].compact.join('/')
+      else
+        url_name = convert_url_name((urlname.blank? ? name : urlname))
+      end
+      write_attribute :urlname, url_name
+    end
+
+    def set_title
+      write_attribute :title, name
+    end
+
+    # Converts the given name into an url friendly string.
+    #
+    # Names shorter than 3 will be filled up with dashes,
+    # so it does not collidate with the language code.
+    #
+    def convert_url_name(name)
+      url_name = convert_to_urlname(name)
+      if url_name.length < 3
+        ('-' * (3 - url_name.length)) + url_name
+      else
+        url_name
+      end
+    end
+
+  end
+end

data/app/models/alchemy/picture.rb

@@ -1,5 +1,6 @@
 module Alchemy
   class Picture < ActiveRecord::Base
+    include NameConversions
 
     has_many :essence_pictures, :class_name => 'Alchemy::EssencePicture', :foreign_key => 'picture_id'
     has_many :contents, :through => :essence_pictures
@@ -22,7 +23,8 @@ module Alchemy
     end
 
     validates_presence_of :image_file
-    validates_property :format, :of => :image_file, :in => Config.get('uploader')['allowed_filetypes']['pictures'], :case_sensitive => false, :message => I18n.t("not a valid image")
+    validates_size_of :image_file, :maximum => Config.get(:uploader)['file_size_limit'].megabytes
+    validates_property :format, :of => :image_file, :in => Config.get(:uploader)['allowed_filetypes']['pictures'], :case_sensitive => false, :message => I18n.t("not a valid image")
 
     acts_as_taggable
 
@@ -38,21 +40,24 @@ module Alchemy
     scope :recent, where("#{self.table_name}.created_at > ?", Time.now-24.hours).order(:created_at)
     scope :deletable, where("alchemy_pictures.id NOT IN (SELECT picture_id FROM alchemy_essence_pictures)")
 
-    def self.find_paginated(params, per_page)
-      Picture.where("name LIKE ?", "%#{params[:query]}%").page(params[:page] || 1).per(per_page).order(:name)
-    end
+    # Class methods
 
-    def self.last_upload
-      last_picture = Picture.last
-      return Picture.scoped unless last_picture
-      Picture.where(:upload_hash => last_picture.upload_hash)
-    end
+    class << self
+
+      def find_paginated(params, per_page)
+        Picture.where("name LIKE ?", "%#{params[:query]}%").page(params[:page] || 1).per(per_page).order(:name)
+      end
+
+      def last_upload
+        last_picture = Picture.last
+        return Picture.scoped unless last_picture
+        Picture.where(:upload_hash => last_picture.upload_hash)
+      end
 
-    # Returning the filepath relative to Rails.root public folder.
-    def public_file_path
-      self.file_path.gsub("#{::Rails.root}/public", '')
     end
 
+    # Instance methods
+
     def urlname
       if self.name.blank?
         "image_#{self.id}"
@@ -67,7 +72,7 @@ module Alchemy
 
     def humanized_name
       return "" if image_file_name.blank?
-      (image_file_name.downcase.gsub(/\.#{::Regexp.quote(suffix)}$/, '')).humanize
+      convert_to_humanized_name(image_file_name, suffix)
     end
 
     # Returning true if picture's width is greater than it's height

data/app/models/alchemy/tag.rb

@@ -1,7 +1,7 @@
 # Just holds some useful tag methods.
 # The original Tag model is ActsAsTaggableOn::Tag
 module Alchemy
-  class Tag
+  class Tag < ActsAsTaggableOn::Tag
 
     # Replaces tag with new tag on all models tagged with tag.
     def self.replace(tag, new_tag)

data/app/models/alchemy/user.rb

@@ -14,15 +14,17 @@ module Alchemy
       :login,
       :email,
       :gender,
-      :role,
       :language,
       :password,
       :password_confirmation,
+      :roles,
       :tag_list
     )
 
     has_many :folded_pages
 
+    validates_presence_of :roles
+
     # Unlock all locked pages before destroy and before the user gets logged out.
     before_destroy :unlock_pages!
     Warden::Manager.before_logout do |user, auth, opts|
@@ -31,7 +33,10 @@ module Alchemy
       end
     end
 
-    scope :admins, where(:role => 'admin')
+    scope :admins, where(arel_table[:roles].matches("%admin%")) # not pleased with that approach
+    # mysql regexp word matching would be much nicer, but it's not included in SQLite functions per se.
+    # scope :admins, where("#{table_name}.roles REGEXP '[[:<:]]admin[[:>:]]'")
+
     scope :logged_in, lambda { where("last_request_at > ?", logged_in_timeout.seconds.ago) }
     scope :logged_out, lambda { where("last_request_at is NULL or last_request_at <= ?", logged_in_timeout.seconds.ago) }
 
@@ -55,15 +60,40 @@ module Alchemy
     end
 
     def role_symbols
-      [role.to_sym]
+      roles.map(&:to_sym)
+    end
+
+    def role
+      roles.first
+    end
+
+    def roles
+      read_attribute(:roles).split(' ')
+    end
+
+    def roles=(roles_string)
+      if roles_string.is_a? Array
+        write_attribute(:roles, roles_string.join(' '))
+      elsif roles_string.is_a? String
+        write_attribute(:roles, roles_string)
+      end
+    end
+
+    def add_role(role)
+      self.roles = self.roles.push(role.to_s).uniq
     end
 
     # Returns true if the user ahs admin role
     def is_admin?
-      role == "admin"
+      has_role? 'admin'
     end
     alias_method :admin?, :is_admin?
 
+    # Returns true if the user has the given role.
+    def has_role?(role)
+      roles.include? role.to_s
+    end
+
     # Calls unlock on all locked pages
     def unlock_pages!
       pages_locked_by_me.map(&:unlock)
@@ -107,8 +137,10 @@ module Alchemy
       !logged_in?
     end
 
-    def human_role_name
-      self.class.human_rolename(self.role)
+    def human_roles_string
+      roles.map do |role|
+        self.class.human_rolename(role)
+      end.to_sentence
     end
 
     def store_request_time!