alchemy_cms 2.9.1 → 3.0.0.rc5

data/app/helpers/alchemy/url_helper.rb

@@ -15,31 +15,6 @@ module Alchemy
       alchemy.show_page_url(show_page_path_params(page, optional_params))
     end
 
-    # This helper returns a path for use inside a link_to helper.
-    #
-    # You may pass a page_layout or an urlname.
-    # Any additional options are passed to the url_helper, so you can add arguments to your url.
-    #
-    # Example:
-    #
-    #   <%= link_to '&raquo order now', page_path_for(:page_layout => 'orderform', :product_id => element.id) %>
-    #
-    def page_path_for(options={})
-      ActiveSupport::Deprecation.warn("Used deprecated page_path_for helper. It will be removed in Alchemy v3.0. You can use show_alchemy_page_path instead.")
-      return warning("No page_layout, or urlname given. I got #{options.inspect} ") if options[:page_layout].blank? && options[:urlname].blank?
-      if options[:urlname].blank?
-        page = Page.find_by_page_layout(options[:page_layout])
-        if page.blank?
-          warning("No page found for #{options.inspect} ")
-          return
-        end
-        urlname = page.urlname
-      else
-        urlname = options[:urlname]
-      end
-      alchemy.show_page_path({:urlname => urlname, :lang => multi_language? ? session[:language_code] : nil}.merge(options.except(:page_layout, :urlname, :lang)))
-    end
-
     # This helper returns a path to picture for use inside a image_tag helper.
     #
     # Any additional options are passed to the url_helper, so you can add arguments to your url.
@@ -92,5 +67,10 @@ module Alchemy
       alchemy.download_attachment_url(attachment, attachment.urlname)
     end
 
+    # Returns the full url containing host, page and anchor for the given element
+    def full_url_for_element(element)
+      "#{current_server}/#{element.page.urlname}##{element_dom_id(element)}"
+    end
+
   end
 end

data/app/models/alchemy/attachment.rb

@@ -1,15 +1,33 @@
-require 'acts-as-taggable-on'
+# == Schema Information
+#
+# Table name: alchemy_attachments
+#
+#  id              :integer          not null, primary key
+#  name            :string(255)
+#  file_name       :string(255)
+#  file_mime_type  :string(255)
+#  file_size       :integer
+#  creator_id      :integer
+#  updater_id      :integer
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#  cached_tag_list :text
+#  file_uid        :string(255)
+#
 
 module Alchemy
   class Attachment < ActiveRecord::Base
     include Alchemy::Filetypes
     include Alchemy::NameConversions
+    include Alchemy::Touching
 
     acts_as_taggable
-    file_accessor :file
-    stampable stamper_class_name: Alchemy.user_class_name
 
-    attr_accessible :file, :name, :file_name, :tag_list
+    dragonfly_accessor :file, app: :alchemy_attachments do
+      after_assign { |f| write_attribute(:file_mime_type, f.mime_type) }
+    end
+
+    stampable stamper_class_name: Alchemy.user_class_name
 
     has_many :essence_files, :class_name => 'Alchemy::EssenceFile', :foreign_key => 'attachment_id'
     has_many :contents, :through => :essence_files
@@ -17,22 +35,21 @@ module Alchemy
     has_many :pages, :through => :elements
 
     validates_presence_of :file
-    validates_format_of :file_name, :with => /^[A-Za-z0-9\.\-_]+$/, :on => :update
-    validates_size_of :file, :maximum => Config.get(:uploader)['file_size_limit'].megabytes
-    validates_property(
-      :format,
-      :of => :file,
-      :in => Config.get(:uploader)['allowed_filetypes']['attachments'],
-      :case_sensitive => false,
-      :message => I18n.t("not a valid file"),
-      :unless => proc { Config.get(:uploader)['allowed_filetypes']['attachments'].include?('*') }
-    )
+    validates_format_of :file_name, with: /\A[A-Za-z0-9\.\-_]+\z/, on: :update
+    validates_size_of :file, maximum: Config.get(:uploader)['file_size_limit'].megabytes
+    validates_property :ext, of: :file,
+      in: Config.get(:uploader)['allowed_filetypes']['attachments'],
+      case_sensitive: false,
+      message: I18n.t("not a valid file"),
+      unless: -> { Config.get(:uploader)['allowed_filetypes']['attachments'].include?('*') }
 
     before_create do
       write_attribute(:name, convert_to_humanized_name(self.file_name, self.file.ext))
       write_attribute(:file_name, sanitized_filename)
     end
 
+    after_update :touch_contents
+
     # Class methods
 
     class << self
@@ -47,6 +64,14 @@ module Alchemy
 
     # Instance methods
 
+    def to_jq_upload
+      {
+        "name" => read_attribute(:file_name),
+        "size" => read_attribute(:file_size),
+        'error' => errors[:file].join
+      }
+    end
+
     def urlname
       read_attribute :file_name
     end

data/app/models/alchemy/cell.rb

@@ -1,3 +1,14 @@
+# == Schema Information
+#
+# Table name: alchemy_cells
+#
+#  id         :integer          not null, primary key
+#  page_id    :integer
+#  name       :string(255)
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
 # A cell is a group of elements that are rendered inside a specific area on your page_layout.
 # Think of it like a column, or section in your layout. I.e. a header or right column.
 #
@@ -14,11 +25,10 @@ module Alchemy
   class Cell < ActiveRecord::Base
     include Alchemy::Logger
 
-    attr_accessible :page_id, :name
-
     belongs_to :page
-    validates_uniqueness_of :name, :scope => :page_id
-    has_many :elements, :dependent => :destroy, :order => :position
+    validates_uniqueness_of :name, scope: 'page_id'
+    validates_format_of :name, with: /\A[a-z0-9_-]+\z/
+    has_many :elements, -> { order(:position) }, dependent: :destroy
 
     class << self
       def definitions
@@ -54,6 +64,10 @@ module Alchemy
       end
     end
 
+    def to_partial_path
+      "alchemy/cells/#{name}"
+    end
+
     # Returns the cell definition defined in +config/alchemy/cells.yml+
     #
     def definition

data/app/models/alchemy/content.rb

@@ -1,46 +1,56 @@
-require 'acts_as_list'
+# == Schema Information
+#
+# Table name: alchemy_contents
+#
+#  id           :integer          not null, primary key
+#  name         :string(255)
+#  essence_type :string(255)
+#  essence_id   :integer
+#  element_id   :integer
+#  position     :integer
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#  creator_id   :integer
+#  updater_id   :integer
+#
 
 module Alchemy
   class Content < ActiveRecord::Base
     include Alchemy::Logger
+    include Alchemy::Touching
+    include Alchemy::Hints
 
     # Concerns
     include Alchemy::Content::Factory
 
-    attr_accessible(
-      :do_not_index,
-      :element_id,
-      :essence_id,
-      :essence_type,
-      :ingredient,
-      :name
-    )
-
     belongs_to :essence, :polymorphic => true, :dependent => :destroy
-    belongs_to :element
+    belongs_to :element, touch: true
 
     stampable stamper_class_name: Alchemy.user_class_name
 
     acts_as_list
 
+    # ActsAsList scope
     def scope_condition
-      "element_id = '#{element_id}' AND essence_type = '#{essence_type}'"
+      # Fixes a bug with postgresql having a wrong element_id value, if element_id is nil.
+      "element_id = #{element_id || 'null'} AND essence_type = '#{essence_type}'"
     end
 
-    #validates_uniqueness_of :name, :scope => :element_id
-    validates_uniqueness_of :position, :scope => [:element_id, :essence_type]
+    # Validations
+    validates :position, uniqueness: {scope: [:element_id, :essence_type]}
 
     # Essence scopes
-    scope :essence_booleans, where(:essence_type => "Alchemy::EssenceBoolean")
-    scope :essence_dates, where(:essence_type => "Alchemy::EssenceDate")
-    scope :essence_files, where(:essence_type => "Alchemy::EssenceFile")
-    scope :essence_htmls, where(:essence_type => "Alchemy::EssenceHtml")
-    scope :essence_links, where(:essence_type => "Alchemy::EssenceLink")
-    scope :essence_pictures, where(:essence_type => "Alchemy::EssencePicture")
-    scope :gallery_pictures, essence_pictures.where("#{self.table_name}.name LIKE 'essence_picture_%'")
-    scope :essence_richtexts, where(:essence_type => "Alchemy::EssenceRichtext")
-    scope :essence_selects, where(:essence_type => "Alchemy::EssenceSelect")
-    scope :essence_texts, where(:essence_type => "Alchemy::EssenceText")
+    scope :essence_booleans,  -> { where(essence_type: "Alchemy::EssenceBoolean") }
+    scope :essence_dates,     -> { where(essence_type: "Alchemy::EssenceDate") }
+    scope :essence_files,     -> { where(essence_type: "Alchemy::EssenceFile") }
+    scope :essence_htmls,     -> { where(essence_type: "Alchemy::EssenceHtml") }
+    scope :essence_links,     -> { where(essence_type: "Alchemy::EssenceLink") }
+    scope :essence_pictures,  -> { where(essence_type: "Alchemy::EssencePicture") }
+    scope :gallery_pictures,  -> { essence_pictures.where("#{self.table_name}.name LIKE 'essence_picture_%'") }
+    scope :essence_richtexts, -> { where(essence_type: "Alchemy::EssenceRichtext") }
+    scope :essence_selects,   -> { where(essence_type: "Alchemy::EssenceSelect") }
+    scope :essence_texts,     -> { where(essence_type: "Alchemy::EssenceText") }
+    scope :named,             ->(name) { where(name: name) }
 
     class << self
       # Returns the translated label for a content name.
@@ -67,6 +77,25 @@ module Alchemy
       end
     end
 
+    # The content's view partial is dependent from its name
+    #
+    # == Define contents
+    #
+    # Contents are defined in the +config/alchemy/elements.yml+ file
+    #
+    #     - name: article
+    #       contents:
+    #       - name: headline
+    #         type: EssenceText
+    #
+    # == Override the view
+    #
+    # Content partials live in +app/views/alchemy/essences+
+    #
+    def to_partial_path
+      "alchemy/essences/#{essence_partial_name}_view"
+    end
+
     # Settings from the elements.yml definition
     def settings
       return {} if description.blank?
@@ -92,15 +121,15 @@ module Alchemy
       essence.ingredient = value
     end
 
-    # Calls essence.update_attributes.
+    # Updates the essence.
     #
-    # Called from +Alchemy::Element#save_contents+
+    # Called from +Alchemy::Element#update_contents+
     #
     # Adds errors to self.base if essence validation fails.
     #
-    def update_essence(params={})
+    def update_essence(params = {})
       raise EssenceMissingError if essence.nil?
-      if essence.update_attributes(params)
+      if essence.update(params)
         return true
       else
         errors.add(:essence, :validation_failed)
@@ -124,18 +153,24 @@ module Alchemy
     #
     # === Options:
     #
-    # You can pass an Essence column_name. Default is self.essence.ingredient_column
+    # You can pass an Essence column_name. Default is 'ingredient'
     #
     # ==== Example:
     #
     #   <%= text_field_tag content.form_field_name(:link), content.ingredient %>
     #
-    def form_field_name(essence_column = self.essence.ingredient_column)
-      "contents[content_#{self.id}][#{essence_column}]"
+    def form_field_name(essence_column = 'ingredient')
+      "contents[#{self.id}][#{essence_column}]"
+    end
+
+    def form_field_id(essence_column = 'ingredient')
+      "contents_#{self.id}_#{essence_column}"
     end
 
-    def form_field_id(essence_column = self.essence.ingredient_column)
-      "contents_content_#{self.id}_#{essence_column}"
+    # Returns a string used as dom id on html elements.
+    def dom_id
+      return '' if essence.nil?
+      "#{essence_partial_name}_#{id}"
     end
 
     # Returns the translated name for displaying in labels, etc.
@@ -159,6 +194,7 @@ module Alchemy
     end
 
     def essence_partial_name
+      return '' if essence.nil?
       essence.partial_name
     end
 
@@ -189,51 +225,5 @@ module Alchemy
       end
     end
 
-    # Returns the hint for this content
-    #
-    # To add a hint to a content pass +hint: true+ to the element definition in its element.yml
-    #
-    # Then the hint itself is placed in the locale yml files.
-    #
-    # Alternativly you can pass the hint itself to the hint key.
-    #
-    # == Locale Example:
-    #
-    #   # elements.yml
-    #   - name: headline
-    #     contents:
-    #     - name: headline
-    #       type: EssenceText
-    #       hint: true
-    #
-    #   # config/locales/de.yml
-    #     de:
-    #       content_hints:
-    #         headline: Lorem ipsum
-    #
-    # == Hint Key Example:
-    #
-    #   - name: headline
-    #     contents:
-    #     - name: headline
-    #       type: EssenceText
-    #       hint: Lorem ipsum
-    #
-    # @return String
-    #
-    def hint
-      hint = definition['hint']
-      if hint == true
-        I18n.t(name, scope: :content_hints)
-      else
-        hint
-      end
-    end
-
-    # Returns true if the element has a hint
-    def has_hint?
-      hint.present?
-    end
-
   end
 end

data/app/models/alchemy/content/factory.rb

@@ -128,10 +128,10 @@ module Alchemy
       #
       def normalize_essence_type(essence_type)
         essence_type = essence_type.classify
-        if essence_type.match(/^Alchemy::/)
+        if essence_type.match(/\AAlchemy::/)
           essence_type
         else
-          essence_type.gsub!(/^Essence/, 'Alchemy::Essence')
+          essence_type.gsub!(/\AEssence/, 'Alchemy::Essence')
         end
       end
 
@@ -172,15 +172,11 @@ module Alchemy
     # Prepares the attributes for creating the essence.
     #
     # 1. It sets a default text if given in +elements.yml+
-    # 2. It sets do_not_index value for EssenceText and EssenceRichtext essences
     #
     def prepared_attributes_for_essence
       attributes = {
         ingredient: default_text(description['default'])
       }
-      if description['type'] == "EssenceRichtext" || description['type'] == "EssenceText"
-        attributes.merge!(do_not_index: !!description['do_not_index'])
-      end
       attributes
     end
 

data/app/models/alchemy/element.rb

@@ -1,34 +1,43 @@
-require 'acts-as-taggable-on'
-require 'acts_as_list'
+# == Schema Information
+#
+# Table name: alchemy_elements
+#
+#  id              :integer          not null, primary key
+#  name            :string(255)
+#  position        :integer
+#  page_id         :integer
+#  public          :boolean          default(TRUE)
+#  folded          :boolean          default(FALSE)
+#  unique          :boolean          default(FALSE)
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#  creator_id      :integer
+#  updater_id      :integer
+#  cell_id         :integer
+#  cached_tag_list :text
+#
 
 module Alchemy
   class Element < ActiveRecord::Base
     include Alchemy::Logger
+    include Alchemy::Touching
+    include Alchemy::Hints
 
     FORBIDDEN_DEFINITION_ATTRIBUTES = %w(contents available_contents amount picture_gallery taggable hint)
     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,
-      :create_contents_after_create,
-      :folded,
-      :name,
-      :page_id,
-      :public,
-      :tag_list,
-      :unique
-    )
-
     # All Elements inside a cell are a list. All Elements not in cell are in the cell_id.nil list.
     acts_as_list :scope => [:page_id, :cell_id]
     stampable stamper_class_name: Alchemy.user_class_name
 
-    has_many :contents, :order => :position, :dependent => :destroy
+    has_many :contents, -> { order(:position) }, dependent: :destroy
     belongs_to :cell
-    belongs_to :page, touch: true
-    has_and_belongs_to_many :to_be_sweeped_pages, :class_name => 'Alchemy::Page', :uniq => true, :join_table => 'alchemy_elements_alchemy_pages'
+    belongs_to :page
+    has_and_belongs_to_many :touchable_pages, -> { uniq },
+      class_name: 'Alchemy::Page',
+      join_table: 'alchemy_elements_alchemy_pages'
 
     validates_uniqueness_of :position, :scope => [:page_id, :cell_id], :if => lambda { |e| e.position != nil }
     validates_presence_of :name, :on => :create
@@ -37,20 +46,20 @@ module Alchemy
     attr_accessor :create_contents_after_create
 
     after_create :create_contents, :unless => proc { |e| e.create_contents_after_create == false }
+    after_update :touch_pages
+
+    scope :trashed,           -> { where(position: nil).order('updated_at DESC') }
+    scope :not_trashed,       -> { where(Element.arel_table[:position].not_eq(nil)) }
+    scope :published,         -> { where(public: true) }
+    scope :not_restricted,    -> { joins(:page).where('alchemy_pages' => {restricted: false}) }
+    scope :available,         -> { published.not_trashed }
+    scope :named,             ->(names) { where(name: names) }
+    scope :excluded,          ->(names) { where(arel_table[:name].not_in(names)) }
+    scope :not_in_cell,       -> { where(cell_id: nil) }
+    scope :in_cell,           -> { where("#{self.table_name}.cell_id IS NOT NULL") }
+    scope :from_current_site, -> { where(alchemy_languages: {site_id: Site.current || Site.default}).joins(page: 'language') }
 
-    scope :trashed, where(:position => nil).order('updated_at DESC')
-    scope :not_trashed, where(Element.arel_table[:position].not_eq(nil))
-    scope :published, where(:public => true)
-    scope :not_restricted, joins(:page).where("alchemy_pages" => {:restricted => false})
-    scope :available, published.not_trashed
-    scope :named, lambda { |names| where(:name => names) }
-    scope :excluded, lambda { |names| where(arel_table[:name].not_in(names)) }
-    scope :not_in_cell, where(:cell_id => nil)
-    scope :in_cell, where("#{self.table_name}.cell_id IS NOT NULL")
-    # Scope for only the elements from Alchemy::Site.current
-    scope :from_current_site, lambda { where(:alchemy_languages => {site_id: Site.current || Site.default}).joins(:page => :language) }
-    # TODO: add this as default_scope
-    #default_scope { from_current_site }
+    delegate :restricted?, to: :page, allow_nil: true
 
     # Concerns
     include Alchemy::Element::Definitions
@@ -106,7 +115,7 @@ module Alchemy
 
       def all_from_clipboard(clipboard)
         return [] if clipboard.nil?
-        find_all_by_id(clipboard.collect { |e| e[:id] })
+        where(id: clipboard.collect { |e| e[:id] })
       end
 
       # All elements in clipboard that could be placed on page
@@ -136,19 +145,19 @@ module Alchemy
       previous_or_next('<', name)
     end
 
-    # Stores the page into `to_be_sweeped_pages` (Pages that have to be sweeped after updating element).
+    # Stores the page into +touchable_pages+ (Pages that have to be touched after updating the element).
     def store_page(page)
       return true if page.nil?
-      unless self.to_be_sweeped_pages.include? page
-        self.to_be_sweeped_pages << page
+      unless self.touchable_pages.include? page
+        self.touchable_pages << page
         self.save
       end
     end
 
     # Trashing an element means nullifying its position, folding and unpublishing it.
     def trash!
-      self.update_column(:public, false)
-      self.update_column(:folded, true)
+      self.public = false
+      self.folded = true
       self.remove_from_list
     end
 
@@ -240,14 +249,26 @@ module Alchemy
       self.ingredient(name).present?
     end
 
-    def save_contents(contents_attributes)
+    # Updates all related contents by calling +update_essence+ on each of them.
+    #
+    # @param contents_attributes [Hash]
+    #   Hash of contents attributes.
+    #   The keys has to be the #id of the content to update.
+    #   The values a Hash of attribute names and values
+    #
+    # @return [Boolean]
+    #   True if +self.errors+ are blank or +contents_attributes+ hash is nil
+    #
+    # == Example
+    #
+    #   @element.update_contents({1 => {ingredient: 'Title'}, 2 => {link: 'https://google.com'}})
+    #
+    def update_contents(contents_attributes)
       return true if contents_attributes.nil?
       contents.each do |content|
-        unless content.update_essence(contents_attributes["content_#{content.id}"])
-          errors.add(:base, :essence_validation_failed)
-        end
+        content.update_essence(contents_attributes["#{content.id}"]) || errors.add(:base, :essence_validation_failed)
       end
-      return errors.blank?
+      errors.blank?
     end
 
     def essences
@@ -331,13 +352,13 @@ module Alchemy
       essence_errors.each do |content_name, errors|
         errors.each do |error|
           messages << I18n.t(
-            "#{name}.#{content_name}.#{error}",
-            :scope => :content_validations,
-            :default => [
+            "#{self.name}.#{content_name}.#{error}",
+            scope: 'content_validations',
+            default: [
               "fields.#{content_name}.#{error}".to_sym,
               "errors.#{error}".to_sym
             ],
-            :field => Content.translated_label_for(content_name)
+            field: Content.translated_label_for(content_name)
           )
         end
       end
@@ -353,7 +374,7 @@ module Alchemy
     end
 
     def rtf_contents
-      contents.essence_richtexts.all
+      contents.essence_richtexts
     end
     alias_method :richtext_contents, :rtf_contents
 
@@ -364,8 +385,9 @@ module Alchemy
     end
 
     # The names of all cells from given page this element could be placed in.
-    def belonging_cellnames(page)
-      cellnames = page.cells.select { |c| c.available_elements.include?(self.name) }.collect(&:name).flatten.uniq
+    #
+    def available_page_cell_names(page)
+      cellnames = unique_available_page_cell_names(page)
       if cellnames.blank? || !page.has_cells?
         ['for_other_elements']
       else
@@ -373,61 +395,30 @@ module Alchemy
       end
     end
 
-    # returns true if the page this element is displayed on is restricted?
-    def restricted?
-      page.restricted?
-    end
-
     # Returns true if the definition of this element has a taggable true value.
     def taggable?
       definition['taggable'] == true
     end
 
-    def to_partial_path
-      "alchemy/elements/#{name}_view"
-    end
-
-    # Returns the hint for this element
-    #
-    # To add a hint to an element either pass +hint: true+ to the element definition in its element.yml
+    # The element's view partial is dependent from its name
     #
-    # Then the hint itself is placed in the locale yml files.
+    # == Define elements
     #
-    # Alternativly you can pass the hint itself to the hint key.
+    # Elements are defined in the +config/alchemy/elements.yml+ file
     #
-    # == Locale Example:
+    #     - name: article
+    #       contents:
+    #       ...
     #
-    #   # elements.yml
-    #   - name: headline
-    #     hint: true
+    # == Override the view
     #
-    #   # config/locales/de.yml
-    #     de:
-    #       element_hints:
-    #         headline: Lorem ipsum
+    # Element partials live in +app/views/alchemy/elements+
     #
-    # == Hint Key Example:
-    #
-    #   - name: headline
-    #     hint: "Lorem ipsum"
-    #
-    # @return String
-    #
-    def hint
-      hint = definition['hint']
-      if hint == true
-        I18n.t(name, scope: :element_hints)
-      else
-        hint
-      end
-    end
-
-    # Returns true if the element has a hint
-    def has_hint?
-      hint.present?
+    def to_partial_path
+      "alchemy/elements/#{name}_view"
     end
 
-  private
+    private
 
     # creates the contents for this element as described in the elements.yml
     def create_contents
@@ -454,5 +445,19 @@ module Alchemy
       elements.reorder("position #{dir == '>' ? 'ASC' : 'DESC'}").limit(1).first
     end
 
+    # Returns all cells from given page this element could be placed in.
+    #
+    def available_page_cells(page)
+      page.cells.select do |cell|
+        cell.available_elements.include?(self.name)
+      end
+    end
+
+    # Returns all uniq cell names from given page this element could be placed in.
+    #
+    def unique_available_page_cell_names(page)
+      available_page_cells(page).collect(&:name).uniq
+    end
+
   end
 end