alchemy_cms 2.9.1 → 3.0.0.rc5

data/app/models/alchemy/folded_page.rb

@@ -1,3 +1,13 @@
+# == Schema Information
+#
+# Table name: alchemy_folded_pages
+#
+#  id      :integer          not null, primary key
+#  page_id :integer
+#  user_id :integer
+#  folded  :boolean          default(FALSE)
+#
+
 module Alchemy
   class FoldedPage < ActiveRecord::Base
     belongs_to :page

data/app/models/alchemy/language.rb

@@ -1,78 +1,95 @@
+# == Schema Information
+#
+# Table name: alchemy_languages
+#
+#  id             :integer          not null, primary key
+#  name           :string(255)
+#  language_code  :string(255)
+#  frontpage_name :string(255)
+#  page_layout    :string(255)      default("intro")
+#  public         :boolean          default(FALSE)
+#  created_at     :datetime         not null
+#  updated_at     :datetime         not null
+#  creator_id     :integer
+#  updater_id     :integer
+#  default        :boolean          default(FALSE)
+#  country_code   :string(255)      default(""), not null
+#  site_id        :integer
+#
+
 module Alchemy
   class Language < ActiveRecord::Base
-
-    attr_accessible(
-      :name,
-      :language_code,
-      :frontpage_name,
-      :page_layout,
-      :public,
-      :default,
-      :country_code,
-      :code,
-      :site
-    )
-
     validates_presence_of :name
     validates_presence_of :language_code
     validates_presence_of :page_layout
     validates_presence_of :frontpage_name
-    validates_uniqueness_of :language_code, :scope => [:site_id, :country_code]
+    validates_uniqueness_of :language_code, scope: [:site_id, :country_code]
     validate :presence_of_default_language
     validate :publicity_of_default_language
     has_many :pages
     belongs_to :site
     after_destroy :delete_language_root_page
-    validates_format_of :language_code, :with => /^[a-z]{2}$/, :if => proc { language_code.present? }
-    validates_format_of :country_code, :with => /^[a-z]{2}$/, :if => proc { country_code.present? }
+    validates_format_of :language_code, with: /\A[a-z]{2}\z/, if: -> { language_code.present? }
+    validates_format_of :country_code, with: /\A[a-z]{2}\z/, if: -> { country_code.present? }
     before_destroy :check_for_default
-    after_update :set_pages_language, :if => proc { |m| m.language_code_changed? || m.country_code_changed? }
-    after_update :unpublish_pages, :if => proc { changes[:public] == [true, false] }
-    before_save :remove_old_default, :if => proc { |m| m.default_changed? && m != Language.get_default }
+    after_update :set_pages_language, if: proc { |m| m.language_code_changed? || m.country_code_changed? }
+    after_update :unpublish_pages, if: proc { changes[:public] == [true, false] }
+    before_save :remove_old_default, if: proc { |m| m.default_changed? && m != Language.default }
 
-    scope :published, where(:public => true)
-    scope :with_language_root, joins(:pages).where("alchemy_pages" => {language_root: true})
-
-    # multi-site support
-    scope :on_site, lambda { |s| s.present? ? where(site_id: s) : scoped }
+    scope :published,      -> { where(public: true) }
+    scope :with_root_page, -> { joins(:pages).where(alchemy_pages: {language_root: true}) }
+    scope :on_site,        ->(s) { s.present? ? where(site_id: s) : all }
     default_scope { on_site(Site.current) }
 
     class << self
 
-      # Returns all languages for which a language root page exists.
-      def all_for_created_language_trees
-        # don't use 'find' here as it would clash with our default_scopes
-        # in various unholy ways you don't want to find out about.
-        where(id: Page.language_roots.collect(&:language_id))
+      # Store the current language in the current thread.
+      def current=(v)
+        Thread.current[:alchemy_current_language] = v
       end
 
-      def all_codes_for_published
-        published.collect(&:code)
-      rescue
-        []
+      # Current language from current thread or default.
+      def current
+        Thread.current[:alchemy_current_language] || default
       end
 
-      def get_default
-        where(default: true).first
+      # The root page of the current language.
+      def current_root_page
+        current.pages.language_roots.first
       end
 
+      # Default language
+      def default
+        find_by(default: true)
+      end
+      alias_method :get_default, :default
     end
 
     def label(attrib)
       if attrib.to_sym == :code
         self.code
       else
-        I18n.t(self.code, :default => self.name)
+        I18n.t(self.code, default: self.name)
       end
     end
 
     include Alchemy::Language::Code
 
-  private
+    # Root page
+    def root_page
+      @root_page ||= pages.language_roots.first
+    end
+
+    # Layout root page
+    def layout_root_page
+      @layout_root_page ||= Page.layout_root_for(id)
+    end
+
+    private
 
     def publicity_of_default_language
       if self.default? && !self.public?
-        errors.add(:base, I18n.t("Default language has to be public"))
+        errors.add(:public, I18n.t("Default language has to be public"))
         return false
       else
         return true
@@ -80,8 +97,8 @@ module Alchemy
     end
 
     def presence_of_default_language
-      if Language.get_default == self && self.default_changed?
-        errors.add(:base, I18n.t("We need at least one default."))
+      if Language.default == self && self.default_changed?
+        errors.add(:default, I18n.t("We need at least one default."))
         return false
       else
         return true
@@ -89,14 +106,14 @@ module Alchemy
     end
 
     def remove_old_default
-      lang = Language.on_site(site).get_default
+      lang = Language.on_site(site).default
       return true if lang.nil?
       lang.default = false
-      lang.save(:validate => false)
+      lang.save(validate: false)
     end
 
     def set_pages_language
-      pages.update_all :language_code => self.code
+      pages.update_all language_code: self.code
     end
 
     def check_for_default
@@ -104,14 +121,11 @@ module Alchemy
     end
 
     def delete_language_root_page
-      page = Page.language_root_for(id)
-      page.destroy if page
-      layoutroot = Page.layout_root_for(id)
-      layoutroot.destroy if layoutroot
+      root_page.try(:destroy) && layout_root_page.try(:destroy)
     end
 
     def unpublish_pages
-      self.pages.update_all(:public => false)
+      self.pages.update_all(public: false)
     end
 
   end

data/app/models/alchemy/legacy_page_url.rb

@@ -1,6 +1,16 @@
+# == Schema Information
+#
+# Table name: alchemy_legacy_page_urls
+#
+#  id         :integer          not null, primary key
+#  urlname    :string(255)      not null
+#  page_id    :integer          not null
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
 class Alchemy::LegacyPageUrl < ActiveRecord::Base
-  attr_accessible :page, :page_id, :urlname
   belongs_to :page, class_name: 'Alchemy::Page'
 
   validates_presence_of [:urlname, :page_id]
-end
+end

data/app/models/alchemy/message.rb

@@ -1,44 +1,27 @@
-# This is a tableless model only used for validating contactform fields.
+# This is a tableless model used for contact forms.
 #
-# You can specify the fields for your contactform in the +config/alchemy/config.yml+ file in the +:mailer+ options.
+# You can specify the fields for your contact form in
+# +config/alchemy/config.yml+ file as +:mailer+ +fields+.
 #
-# === Example Contactform Configuration:
+# === Example Configuration:
 #
 #   mailer:
 #     form_layout_name: contact
 #     fields: [subject, name, email, message, info]
 #     validate_fields: [name, email]
-
+#
 module Alchemy
   class Message
+    include ActiveModel::Model
 
-    extend ::ActiveModel::Naming
-    include ::ActiveModel::Validations
-    include ::ActiveModel::Conversion
-    include ::ActiveModel::MassAssignmentSecurity
-
-    class << self
-      def attr_accessor(*vars)
-        @attributes ||= {}
-        vars.map { |v| @attributes[v] = nil}
-        super(*vars)
-      end
-
-      def attributes
-        @attributes
-      end
-
-      def config
-        Config.get(:mailer)
-      end
+    def self.config
+      Alchemy::Config.get(:mailer)
     end
 
     attr_accessor :contact_form_id, :ip
-    attr_accessible :contact_form_id
 
     config['fields'].each do |field|
       attr_accessor field.to_sym
-      attr_accessible field.to_sym
     end
 
     config['validate_fields'].each do |field|
@@ -46,27 +29,12 @@ module Alchemy
 
       case field.to_sym
       when :email
-        validates_format_of field, with: Alchemy::Config.get(:email_regexp), if: -> { email.present? }
+        validates_format_of field,
+          with: Alchemy::Config.get('format_matchers')['email'],
+          if: -> { email.present? }
       when :email_confirmation
         validates_confirmation_of :email
       end
     end
-
-    def initialize(attributes = {})
-      @attributes ||= {}
-      attributes.keys.each do |a|
-        send("#{a}=", attributes[a])
-        @attributes[a] = attributes[a]
-      end
-    end
-
-    def attributes
-      self.class.attributes
-    end
-
-    def persisted? #:nodoc:
-      false
-    end
-
   end
 end

data/app/models/alchemy/page.rb

@@ -1,8 +1,41 @@
-require 'acts-as-taggable-on'
-require 'awesome_nested_set'
+# == Schema Information
+#
+# Table name: alchemy_pages
+#
+#  id               :integer          not null, primary key
+#  name             :string(255)
+#  urlname          :string(255)
+#  title            :string(255)
+#  language_code    :string(255)
+#  language_root    :boolean
+#  page_layout      :string(255)
+#  meta_keywords    :text
+#  meta_description :text
+#  lft              :integer
+#  rgt              :integer
+#  parent_id        :integer
+#  depth            :integer
+#  visible          :boolean          default(FALSE)
+#  public           :boolean          default(FALSE)
+#  locked           :boolean          default(FALSE)
+#  locked_by        :integer
+#  restricted       :boolean          default(FALSE)
+#  robot_index      :boolean          default(TRUE)
+#  robot_follow     :boolean          default(TRUE)
+#  sitemap          :boolean          default(TRUE)
+#  layoutpage       :boolean          default(FALSE)
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#  creator_id       :integer
+#  updater_id       :integer
+#  language_id      :integer
+#  cached_tag_list  :text
+#
 
 module Alchemy
   class Page < ActiveRecord::Base
+    include Alchemy::Hints
+    include Alchemy::Touching
 
     DEFAULT_ATTRIBUTES_FOR_COPY = {
       :do_not_autogenerate => true,
@@ -13,22 +46,11 @@ module Alchemy
       :locked_by => nil
     }
     SKIPPED_ATTRIBUTES_ON_COPY = %w(id updated_at created_at creator_id updater_id lft rgt depth urlname cached_tag_list)
-
-    attr_accessible(
-      :do_not_autogenerate,
-      :do_not_sweep,
-      :language_code,
-      :language,
-      :language_id,
-      :language_root,
-      :layoutpage,
-      :locked,
-      :locked_by,
+    PERMITTED_ATTRIBUTES = [
       :meta_description,
       :meta_keywords,
       :name,
       :page_layout,
-      :parent_id,
       :public,
       :restricted,
       :robot_index,
@@ -37,8 +59,9 @@ module Alchemy
       :tag_list,
       :title,
       :urlname,
-      :visible
-    )
+      :visible,
+      :layoutpage
+    ]
 
     acts_as_taggable
     acts_as_nested_set(:dependent => :destroy)
@@ -53,23 +76,25 @@ module Alchemy
 
     validates_presence_of :language, :on => :create, :unless => :root
     validates_presence_of :page_layout, :unless => :systempage?
+    validates_format_of :page_layout, with: /\A[a-z0-9_-]+\z/, unless: -> { systempage? || page_layout.blank? }
     validates_presence_of :parent_id, :if => proc { Page.count > 1 }
 
     attr_accessor :do_not_sweep
     attr_accessor :do_not_validate_language
 
-    before_save :set_language_code, :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?
+    before_save :set_language_code, if: -> { language.present? }, unless: :systempage?
+    before_save :set_restrictions_to_child_pages, if: :restricted_changed?, unless: :systempage?
+    before_save :inherit_restricted_status, if: -> { parent && parent.restricted? }, unless: :systempage?
+    before_create :set_language_from_parent_or_default, if: -> { language_id.blank? }, unless: :systempage?
+    after_update :create_legacy_url, if: :urlname_changed?, unless: :redirects_to_external?
 
     # Concerns
-    include Alchemy::Page::PageScopes
-    include Alchemy::Page::PageNatures
-    include Alchemy::Page::PageNaming
-    include Alchemy::Page::PageUsers
-    include Alchemy::Page::PageCells
-    include Alchemy::Page::PageElements
+    include Alchemy::Page::Scopes
+    include Alchemy::Page::Natures
+    include Alchemy::Page::Naming
+    include Alchemy::Page::Users
+    include Alchemy::Page::Cells
+    include Alchemy::Page::Elements
 
     # Class methods
     #
@@ -77,6 +102,18 @@ module Alchemy
 
       alias_method :rootpage, :root
 
+      # Used to store the current page previewed in the edit page template.
+      #
+      def current_preview=(page)
+        Thread.current[:alchemy_current_preview] = page
+      end
+
+      # Returns the current page previewed in the edit page template.
+      #
+      def current_preview
+        Thread.current[:alchemy_current_preview]
+      end
+
       # @return the language root page for given language id.
       # @param language_id [Fixnum]
       #
@@ -117,21 +154,16 @@ module Alchemy
         layoutroot = layout_root_for(language_id)
         return layoutroot if layoutroot
         language = Language.find(language_id)
-        layoutroot = Page.new({
-          :name => "Layoutroot for #{language.name}",
-          :layoutpage => true,
-          :language => language,
-          :do_not_autogenerate => true
-        })
-        if layoutroot.save(:validate => false)
-          layoutroot.move_to_child_of(Page.root)
-          return layoutroot
-        else
-          raise "Layout root for #{language.name} could not be created"
-        end
+        Page.create!(
+          name: "Layoutroot for #{language.name}",
+          layoutpage: true,
+          language: language,
+          do_not_autogenerate: true,
+          parent_id: Page.root.id
+        )
       end
 
-      def paste_from_clipboard(source, new_parent, new_name)
+      def copy_and_paste(source, new_parent, new_name)
         page = copy(source, {
           parent_id: new_parent.id,
           language: new_parent.language,
@@ -146,7 +178,7 @@ module Alchemy
 
       def all_from_clipboard(clipboard)
         return [] if clipboard.blank?
-        self.find_all_by_id(clipboard.collect { |i| i[:id] })
+        where(id: clipboard.collect { |p| p[:id] })
       end
 
       def all_from_clipboard_for_select(clipboard, language_id, layoutpage = false)
@@ -204,11 +236,22 @@ module Alchemy
     # Instance methods
     #
 
-    # Touches the timestamps and userstamps
-    def touch
-      update_hash = {updated_at: Time.now}
-      update_hash[:updater_id] = Alchemy.user_class.stamper if Alchemy.user_class.respond_to?(:stamper)
-      Page.where(id: self.id).update_all(update_hash)
+    # The page's view partial is dependent from its page layout
+    #
+    # == Define page layouts
+    #
+    # Page layouts are defined in the +config/alchemy/page_layouts.yml+ file
+    #
+    #     - name: contact
+    #       elements: [contactform]
+    #       ...
+    #
+    # == Override the view
+    #
+    # Page layout partials live in +app/views/alchemy/page_layouts+
+    #
+    def to_partial_path
+      "alchemy/page_layouts/#{layout_partial_name}"
     end
 
     # Returns the previous page on the same level or nil.
@@ -231,30 +274,24 @@ module Alchemy
 
     # 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)
+    def lock_to!(user)
+      self.update_columns(locked: true, locked_by: user.id)
     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)
+      if self.update_columns(locked: false, locked_by: nil)
+        Page.current_preview = nil
+      end
     end
 
     def fold!(user_id, status)
-      folded_page = folded_pages.find_or_create_by_user_id(user_id)
+      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
-
     def set_restrictions_to_child_pages
       descendants.each do |child|
         child.update_attributes(:restricted => self.restricted?)
@@ -272,7 +309,7 @@ module Alchemy
 
     # Gets the language_root page for page
     def get_language_root
-      self_and_ancestors.where(:language_root => true).first
+      self_and_ancestors.find_by(language_root: true)
     end
 
     def copy_children_to(new_parent)
@@ -287,39 +324,17 @@ module Alchemy
       end
     end
 
-    # Publishes the page
-    #
-    # Sets public true and saves the object.
-    def publish!
-      self.public = true
-      self.save
-    end
-
-    def set_language_from_parent_or_default_language
-      self.language = self.parent.language || Language.get_default
-      set_language_code
-    end
-
-    # Updates an Alchemy::Page based on a new ordering to be applied to it
+    # Publishes the page.
     #
-    # 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
+    # Sets +public+ to true and the +published_at+ value to current time.
     #
-    # @param [TreeNode]
-    #   A tree node with new lft, rgt, depth, url, parent_id and restricted indexes to be updated
+    # The +published_at+ attribute is used as +cache_key+.
     #
-    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 publish!
+      update_columns(published_at: Time.now, public: true)
     end
 
-  private
+    private
 
     # Returns the next or previous page on the same level or nil.
     #
@@ -345,14 +360,18 @@ module Alchemy
         .limit(1).first
     end
 
+    def set_language_from_parent_or_default
+      self.language = self.parent.language || Language.default
+      set_language_code
+    end
+
     def set_language_code
-      return false if self.language.blank?
       self.language_code = self.language.code
     end
 
     # Stores the old urlname in a LegacyPageUrl
     def create_legacy_url
-      legacy_urls.find_or_create_by_urlname(:urlname => urlname_was)
+      legacy_urls.find_or_create_by(urlname: urlname_was)
     end
 
   end