alchemy_cms 2.6.3 → 2.7.0

data/app/models/alchemy/element/definitions.rb

@@ -0,0 +1,52 @@
+module Alchemy
+
+  # Module concerning element definitions
+  #
+  module Element::Definitions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Returns the definitions from elements.yml file.
+      #
+      # Place a +elements.yml+ file inside your apps +config/alchemy+ folder to define
+      # your own set of elements
+      #
+      def definitions
+        @definitions ||= read_definitions_file
+      end
+      alias_method :descriptions, :definitions
+
+    private
+
+      # Reads the element definitions file named +elements.yml+ from +config/alchemy/+ folder.
+      #
+      def read_definitions_file
+        if ::File.exists?(definitions_file_path)
+          ::YAML.load_file(definitions_file_path) || []
+        else
+          raise LoadError, "Could not find elements.yml file! Please run `rails generate alchemy:scaffold`"
+        end
+      end
+
+      # Returns the +elements.yml+ file path
+      #
+      def definitions_file_path
+        Rails.root.join 'config/alchemy/elements.yml'
+      end
+    end
+
+    # The definition of this element.
+    #
+    def definition
+      if definition = self.class.definitions.detect { |d| d['name'] == name }
+        definition
+      else
+        log_warning "Could not find element definition for #{self.name}. Please check your elements.yml file!"
+        return {}
+      end
+    end
+    alias_method :description, :definition
+
+  end
+end

data/app/models/alchemy/element/presenters.rb

@@ -0,0 +1,87 @@
+module Alchemy
+
+  # Methods used for presenting an Alchemy Element.
+  #
+  module Element::Presenters
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Human name for displaying elements in select boxes and element editor views.
+      #
+      # The name is beeing translated from given name value as described in +config/alchemy/elements.yml+
+      #
+      # Translate the name in your +config/locales+ language file.
+      #
+      # == Example:
+      #
+      #   de:
+      #     alchemy:
+      #       element_names:
+      #         contactform: 'Kontakt Formular'
+      #
+      # If no translation is found a humanized name is used.
+      #
+      def display_name_for(name)
+        I18n.t(name, scope: 'element_names', default: name.to_s.humanize)
+      end
+    end
+
+    # Returns the translated name
+    #
+    # @see Alchemy::Element::Presenters#display_name_for
+    #
+    def display_name
+      self.class.display_name_for(description['name'] || self.name)
+    end
+
+    # Returns a preview text for element.
+    #
+    # It's taken from the first Content found in the +elements.yml+ description file.
+    #
+    # You can flag a Content as +take_me_for_preview+ to take this as preview.
+    #
+    # @param maxlength [Fixnum] (30)
+    #   Length of characters after the text will be cut off.
+    #
+    def preview_text(maxlength = 30)
+      (contents.detect(&:preview_content?) || contents.first).try(:preview_text, maxlength)
+    end
+
+    # Generates a preview text containing Element#display_name and Element#preview_text.
+    #
+    # It is displayed inside the head of the Element in the Elements.list overlay window from the Alchemy Admin::Page#edit view.
+    #
+    # === Example
+    #
+    # A Element described as:
+    #
+    #     - name: funky_element
+    #       display_name: Funky Element
+    #       contents:
+    #       - name: headline
+    #         type: EssenceText
+    #       - name: text
+    #         type EssenceRichtext
+    #         take_me_for_preview: true
+    #
+    # With "I want to tell you a funky story" as stripped_body for the EssenceRichtext Content produces:
+    #
+    #     Funky Element: I want to tell ...
+    #
+    # @param maxlength [Fixnum] (30)
+    #   Length of characters after the text will be cut off.
+    #
+    def display_name_with_preview_text(maxlength = 30)
+      "#{display_name}: #{preview_text(maxlength)}"
+    end
+
+    # Returns a dom id used for elements html id tag.
+    #
+    def dom_id
+      "#{name}_#{id}"
+    end
+
+  end
+
+end

data/app/models/alchemy/essence_date.rb

@@ -8,7 +8,7 @@ module Alchemy
     )
 
     # Returns self.date for the Element#preview_text method.
-    def preview_text(foo=nil)
+    def preview_text
       return "" if date.blank?
       ::I18n.l(date, :format => :date)
     end

data/app/models/alchemy/essence_file.rb

@@ -1,14 +1,13 @@
 module Alchemy
   class EssenceFile < ActiveRecord::Base
-
     attr_accessible :title, :css_class, :attachment_id
-
-    acts_as_essence(
-      :ingredient_column => :attachment,
-      :preview_text_method => :name
-    )
-
     belongs_to :attachment
+    acts_as_essence ingredient_column: 'attachment'
+
+    def preview_text(max=30)
+      return "" if attachment.blank?
+      attachment.name.to_s[0..max-1]
+    end
 
   end
 end

data/app/models/alchemy/essence_picture.rb

@@ -16,15 +16,30 @@ module Alchemy
       :picture_id
     )
 
-    acts_as_essence(
-      :ingredient_column => :picture,
-      :preview_text_method => :name
-    )
+    acts_as_essence ingredient_column: 'picture'
 
     belongs_to :picture
     before_save :fix_crop_values
     before_save :replace_newlines
 
+    def preview_text(max=30)
+      return "" if picture.nil?
+      picture.name.to_s[0..max-1]
+    end
+
+    # Returns a hash suitable for the js image cropper.
+    #
+    def cropping_mask
+      crop_from = self.crop_from.split('x')
+      crop_size = self.crop_size.split('x')
+      {
+        x1: crop_from[0].to_i,
+        y1: crop_from[1].to_i,
+        x2: crop_from[0].to_i + crop_size[0].to_i,
+        y2: crop_from[1].to_i + crop_size[1].to_i
+      }
+    end
+
   private
 
     def fix_crop_values

data/app/models/alchemy/message.rb

@@ -17,31 +17,31 @@ module Alchemy
     include ::ActiveModel::Conversion
     include ::ActiveModel::MassAssignmentSecurity
 
-    def self.attr_accessor(*vars)
-      @attributes ||= {}
-      vars.map { |v| @attributes[v] = nil}
-      super(*vars)
-    end
+    class << self
+      def attr_accessor(*vars)
+        @attributes ||= {}
+        vars.map { |v| @attributes[v] = nil}
+        super(*vars)
+      end
 
-    def self.attributes
-      @attributes
-    end
+      def attributes
+        @attributes
+      end
 
-    def attributes
-      self.class.attributes
+      def config
+        Config.get(:mailer)
+      end
     end
 
-    @@config = Config.get(:mailer)
-
     attr_accessor :contact_form_id, :ip
     attr_accessible :contact_form_id
 
-    @@config['fields'].each do |field|
+    config['fields'].each do |field|
       attr_accessor field.to_sym
       attr_accessible field.to_sym
     end
 
-    @@config['validate_fields'].each do |field|
+    config['validate_fields'].each do |field|
       validates_presence_of field
 
       case field.to_sym
@@ -60,6 +60,10 @@ module Alchemy
       end
     end
 
+    def attributes
+      self.class.attributes
+    end
+
     def persisted? #:nodoc:
       false
     end

data/app/models/alchemy/page.rb

@@ -1,3 +1,7 @@
+require 'acts-as-taggable-on'
+require 'awesome_nested_set'
+require 'userstamp'
+
 module Alchemy
   class Page < ActiveRecord::Base
 
@@ -45,6 +49,7 @@ module Alchemy
     has_many :folded_pages
     has_many :legacy_urls, :class_name => 'Alchemy::LegacyPageUrl'
     belongs_to :language
+    belongs_to :locker, class_name: 'Alchemy::User', foreign_key: 'locked_by'
 
     validates_presence_of :language, :on => :create, :unless => :root
     validates_presence_of :page_layout, :unless => :systempage?
@@ -54,37 +59,15 @@ module Alchemy
     attr_accessor :do_not_validate_language
 
     before_save :set_language_code, :unless => :systempage?
-    before_save :inherit_restricted_status, if: -> { parent && parent.restricted? }, unless: :systempage?
-    after_update :set_restrictions_to_child_pages, unless: :systempage?
+    before_save :set_restrictions_to_child_pages, :if => :restricted_changed?, :unless => :systempage?
+    before_save :inherit_restricted_status, :if => proc { parent && parent.restricted? }, :unless => :systempage?
     after_update :create_legacy_url, :if => :urlname_changed?, :unless => :redirects_to_external?
 
-    scope :language_roots, where(:language_root => true)
-    scope :layoutpages, where(:layoutpage => true)
-    scope :all_locked, where(:locked => true)
-    scope :all_locked_by, lambda { |user| where(:locked => true, :locked_by => user.id) }
-    scope :not_locked, where(:locked => false)
-    scope :visible, where(:visible => true)
-    scope :published, where(:public => true)
-    scope :not_restricted, where(:restricted => false)
-    scope :restricted, where(:restricted => true)
-    scope :public_language_roots, lambda {
-      where(:language_root => true, :language_code => Language.all_codes_for_published, :public => true)
-    }
-    scope :all_last_edited_from, lambda { |user| where(:updater_id => user.id).order('updated_at DESC').limit(5) }
-    # Returns all pages that have the given language_id
-    scope :with_language, lambda { |language_id| where(:language_id => language_id) }
-    scope :contentpages, where(:layoutpage => [false, nil]).where(Page.arel_table[:parent_id].not_eq(nil))
-    # Returns all pages that are not locked and public.
-    # Used for flushing all page caches at once.
-    scope :flushables, not_locked.published.contentpages
-    scope :searchables, not_restricted.published.contentpages
-    # Scope for only the pages from Alchemy::Site.current
-    scope :from_current_site, lambda { where(:alchemy_languages => {site_id: Site.current || Site.default}).joins(:language) }
-    # TODO: add this as default_scope
-    #default_scope { from_current_site }
-
     # Concerns
+    include Scopes
+    include Natures
     include Naming
+    include Users
     include Cells
     include Elements
 
@@ -101,26 +84,23 @@ module Alchemy
         self.language_roots.find_by_language_id(language_id)
       end
 
-      # Creates a copy of source
+      # Creates a copy of given source.
       #
       # Also copies all elements included in source.
       #
       # === Note:
+      #
       # It prevents the element auto generator from running.
       #
       # @param source [Alchemy::Page]
+      #   The source page the copy is taken from
       # @param differences [Hash]
+      #   A optional hash with attributes that take precedence over the source attributes
       #
       # @return [Alchemy::Page]
       #
       def copy(source, differences = {})
-        source.attributes.stringify_keys!
-        differences.stringify_keys!
-        attributes = source.attributes.merge(differences)
-        attributes.merge!(DEFAULT_ATTRIBUTES_FOR_COPY)
-        new_name = differences['name'].present? ? differences['name'] : "#{source.name} (#{I18n.t('Copy')})"
-        attributes.merge!('name' => new_name)
-        page = self.new(attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY))
+        page = Alchemy::Page.new(attributes_from_source_for_copy(source, differences))
         page.tag_list = source.tag_list
         if page.save!
           copy_cells(source, page)
@@ -151,6 +131,19 @@ module Alchemy
         end
       end
 
+      def paste_from_clipboard(source, new_parent, new_name)
+        page = copy(source, {
+          parent_id: new_parent.id,
+          language: new_parent.language,
+          name: new_name,
+          title: new_name
+        })
+        if source.children.any?
+          source.copy_children_to(page)
+        end
+        return page
+      end
+
       def all_from_clipboard(clipboard)
         return [] if clipboard.blank?
         self.find_all_by_id(clipboard.collect { |i| i[:id] })
@@ -173,151 +166,101 @@ module Alchemy
         options
       end
 
-    end
-
-    # Instance methods
-    #
-
-    # Finds the previous page on the same structure level. Otherwise it returns nil.
-    # Options:
-    # => :restricted => boolean (standard: nil) - next restricted page (true), skip restricted pages (false), ignore restriction (nil)
-    # => :public => boolean (standard: true) - next public page (true), skip public pages (false)
-    def previous(options = {})
-      next_or_previous(:previous, {
-        :restricted => nil,
-        :public => true
-      }.merge(options))
-    end
-    alias_method :previous_page, :previous
-
-    # Finds the next page on the same structure level. Otherwise it returns nil.
-    # Options:
-    # => :restricted => boolean (standard: nil) - next restricted page (true), skip restricted pages (false), ignore restriction (nil)
-    # => :public => boolean (standard: true) - next public page (true), skip public pages (false)
-    def next(options = {})
-      next_or_previous(:next, {
-        :restricted => nil,
-        :public => true
-      }.merge(options))
-    end
-    alias_method :next_page, :next
-
-    def lock(user)
-      self.locked = true
-      self.locked_by = user.id
-      self.save(:validate => false)
-    end
-
-    def unlock
-      self.locked = false
-      self.locked_by = nil
-      self.do_not_sweep = true
-      self.save
-    end
-
-    # Returns the name of the creator of this page.
-    def creator
-      @page_creator ||= User.find_by_id(creator_id)
-      return I18n.t('unknown') if @page_creator.nil?
-      @page_creator.name
-    end
+    private
 
-    # Returns the name of the last updater of this page.
-    def updater
-      @page_updater = User.find_by_id(updater_id)
-      return I18n.t('unknown') if @page_updater.nil?
-      @page_updater.name
-    end
+      # Aggregates the attributes from given source for copy of page.
+      #
+      # @param [Alchemy::Page]
+      #   The source page
+      # @param [Hash]
+      #   A optional hash with attributes that take precedence over the source attributes
+      #
+      def attributes_from_source_for_copy(source, differences = {})
+        source.attributes.stringify_keys!
+        differences.stringify_keys!
+        attributes = source.attributes.merge(differences)
+        attributes.merge!(DEFAULT_ATTRIBUTES_FOR_COPY)
+        attributes.merge!('name' => new_name_for_copy(differences['name'], source.name))
+        attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY)
+      end
 
-    # Returns the name of the user currently editing this page.
-    def current_editor
-      @current_editor = User.find_by_id(locked_by)
-      return I18n.t('unknown') if @current_editor.nil?
-      @current_editor.name
-    end
+      # Returns a new name for copy of page.
+      #
+      # If the differences hash includes a new name this is taken.
+      # Otherwise +source.name+
+      #
+      # @param [String]
+      #   The differences hash that contains a new name
+      # @param [String]
+      #   The name of the source
+      #
+      def new_name_for_copy(custom_name, source_name)
+        return custom_name if custom_name.present?
+        "#{source_name} (#{I18n.t('Copy')})"
+      end
 
-    def locker
-      User.find_by_id(self.locked_by)
     end
 
-    def fold(user_id, status)
-      folded_page = FoldedPage.find_or_create_by_user_id_and_page_id(user_id, self.id)
-      folded_page.folded = status
-      folded_page.save
-    end
+    # Instance methods
+    #
 
-    def folded?(user_id)
-      folded_page = FoldedPage.find_by_user_id_and_page_id(user_id, self.id)
-      return false if folded_page.nil?
-      folded_page.folded
+    # Touches the timestamps and userstamps
+    def touch
+      Page.where(id: self.id).update_all(updated_at: Time.now, updater_id: User.stamper)
     end
 
-    # Returns a Hash describing the status of the Page.
+    # Returns the previous page on the same level or nil.
+    #
+    # For options @see #next_or_previous
     #
-    def status
-      {
-        visible: visible?,
-        public: public?,
-        locked: locked?,
-        restricted: restricted?
-      }
+    def previous(options = {})
+      next_or_previous('<', options)
     end
+    alias_method :previous_page, :previous
 
-    # Returns the translated status for given status type.
+    # Returns the next page on the same level or nil.
     #
-    # @param [Symbol] status_type
+    # For options @see #next_or_previous
     #
-    def status_title(status_type)
-      I18n.t(self.status[status_type].to_s, scope: "page_states.#{status_type}")
-    end
-
-    def has_controller?
-      !PageLayout.get(self.page_layout).nil? && !PageLayout.get(self.page_layout)["controller"].blank?
+    def next(options = {})
+      next_or_previous('>', options)
     end
+    alias_method :next_page, :next
 
-    def controller_and_action
-      if self.has_controller?
-        controller = self.layout_description["controller"].gsub(/^([^\/])/, "/#{$1}")
-        {:controller => controller, :action => self.layout_description["action"]}
-      end
+    # Locks the page to given user without updating the timestamps
+    #
+    def lock!(user)
+      # Yes, since +update_columns+ is not available in Rails 3.2,
+      # we use this workaround to update straight in the db.
+      Page.where(id: self.id).update_all(locked: true, locked_by: user.id)
     end
 
-    # Returns the self#page_layout description from config/alchemy/page_layouts.yml file.
-    def layout_description
-      return {} if self.systempage?
-      description = PageLayout.get(self.page_layout)
-      if description.nil?
-        raise PageLayoutDefinitionError, "Description could not be found for page layout named #{self.page_layout}. Please check page_layouts.yml file."
-      else
-        description
-      end
+    # Unlocks the page without updating the timestamps
+    #
+    def unlock!
+      # Yes, since +update_columns+ is not available in Rails 3.2,
+      # we use this workaround to update straight in the db.
+      Page.where(id: self.id).update_all(locked: false, locked_by: nil)
     end
-    alias_method :definition, :layout_description
 
-    # Returns translated name of the pages page_layout value.
-    # Page layout names are defined inside the config/alchemy/page_layouts.yml file.
-    # Translate the name in your config/locales language yml file.
-    def layout_display_name
-      I18n.t(self.page_layout, :scope => :page_layout_names)
+    def fold!(user_id, status)
+      folded_page = folded_pages.find_or_create_by_user_id(user_id)
+      folded_page.folded = status
+      folded_page.save
     end
 
     def changed_publicity?
       self.public_was != self.public
     end
 
-    # Sets my restricted value to all child pages
-    #
     def set_restrictions_to_child_pages
-      descendants.update_all(restricted: self.restricted?)
-    end
-
-    def contains_feed?
-      definition["feed"]
+      descendants.each do |child|
+        child.update_attributes(:restricted => self.restricted?)
+      end
     end
 
-    # Returns true or false if the pages layout_description for config/alchemy/page_layouts.yml contains redirects_to_external: true
-    def redirects_to_external?
-      !!definition["redirects_to_external"]
+    def inherit_restricted_status
+      self.restricted = parent.restricted?
     end
 
     # Returns the first published child
@@ -342,29 +285,6 @@ module Alchemy
       end
     end
 
-    def locker_name
-      return I18n.t('unknown') if self.locker.nil?
-      self.locker.name
-    end
-
-    def rootpage?
-      !self.new_record? && self.parent_id.blank?
-    end
-
-    def systempage?
-      return true if Page.root.nil?
-      rootpage? || (self.parent_id == Page.root.id && !self.language_root?)
-    end
-
-    # Overwrites the cache_key method.
-    def cache_key(request = nil)
-      "alchemy/pages/#{id}"
-    end
-
-    def taggable?
-      definition['taggable'] == true
-    end
-
     # Publishes the page
     #
     # Sets public true and saves the object.
@@ -373,43 +293,35 @@ module Alchemy
       self.save
     end
 
-    # Updates an Alchemy::Page based on a new ordering to be applied to it
-    #
-    # Note: Page's urls should not be updated (and a legacy URL created) if nesting is OFF
-    # or if a page is external or if the URL is the same
-    #
-    # @param [TreeNode]
-    #   A tree node with new lft, rgt, depth, url, parent_id and restricted indexes to be updated
-    #
-    def update_node!(node)
-      hash = {lft: node.left, rgt: node.right, parent_id: node.parent, depth: node.depth, restricted: node.restricted}
-
-      if Config.get(:url_nesting) && !self.redirects_to_external? && self.urlname != node.url
-        LegacyPageUrl.create(page_id: self.id, urlname: self.urlname)
-        hash.merge!(urlname: node.url)
-      end
-
-      self.class.update_all(hash, {id: self.id})
+    def set_language_from_parent_or_default_language
+      self.language = self.parent.language || Language.get_default
+      set_language_code
     end
 
   private
 
-    def next_or_previous(direction = :next, options = {})
-      pages = self.class.scoped
-      if direction == :previous
-        step_direction = ["#{self.class.table_name}.lft < ?", self.lft]
-        order_direction = "lft DESC"
-      else
-        step_direction = ["#{self.class.table_name}.lft > ?", self.lft]
-        order_direction = "lft"
-      end
-      pages = pages.where(:public => options[:public])
-      pages = pages.where(:parent_id => self.parent_id)
-      pages = pages.where(step_direction)
-      if !options[:restricted].nil?
-        pages = pages.where(:restricted => options[:restricted])
-      end
-      pages.order(order_direction).limit(1).first
+    # Returns the next or previous page on the same level or nil.
+    #
+    # @param [String]
+    #   Pass '>' for next and '<' for previous page.
+    #
+    # @option options [Boolean] :restricted (nil)
+    #   only restricted pages (true), skip restricted pages (false)
+    # @option options [Boolean] :public (true)
+    #   only public pages (true), skip public pages (false)
+    #
+    def next_or_previous(dir = '>', options = {})
+      options = {
+        restricted: false,
+        public: true
+      }.update(options)
+
+      self_and_siblings
+        .where(["#{self.class.table_name}.lft #{dir} ?", lft])
+        .where(public: options[:public])
+        .where(restricted: options[:restricted])
+        .order(dir == '>' ? 'lft' : 'lft DESC')
+        .limit(1).first
     end
 
     def set_language_code
@@ -422,11 +334,5 @@ module Alchemy
       legacy_urls.find_or_create_by_urlname(:urlname => urlname_was)
     end
 
-    # Sets my restricted status to parent's restricted status
-    #
-    def inherit_restricted_status
-      self.restricted = parent.restricted?
-    end
-
   end
 end