alchemy_cms 2.4.1 → 2.5.0.b2

data/app/helpers/alchemy/pages_helper.rb

@@ -3,8 +3,6 @@ module Alchemy
 
     include Alchemy::BaseHelper
     include Alchemy::ElementsHelper
-    include Alchemy::ElementsBlockHelper
-    include Alchemy::UrlHelper
 
     def render_classes(classes=[])
       s = classes.uniq.delete_if { |x| x.blank? }.join(" ")
@@ -445,19 +443,41 @@ module Alchemy
       javascript_include_tag("alchemy/preview") if @preview_mode
     end
 
-    # Renders the search form
+    # Renders a search form
+    #
+    # It queries the controller and then redirects to the search result page.
+    #
+    # === Example search results page layout
+    #
+    # Only performs the search if ferret is enabled in your +config/alchemy/config.yml+ and
+    # a page is present that is flagged with +searchresults+ true.
+    #
+    #   # config/alchemy/page_layouts.yml
+    #   - name: search
+    #     searchresults: true # Flag as search result page
+    #
+    # === Note
+    #
+    # The search result page will not be cached.
+    #
+    # @option options html5 [Boolean] (true) Should the search form be of type search or not?
+    # @option options class [String] (fulltext_search) The default css class of the form
+    # @option options id [String] (search) The default css id of the form
+    #
     def render_search_form(options={})
       default_options = {
-        :html5 => false
+        :html5 => false,
+        :class => 'fulltext_search',
+        :id => 'search'
       }
-      if @search_result_page.blank?
-        warning("No search result page found")
-        return
-      end
-      render :partial => 'alchemy/search/form', :locals => {:options => default_options.merge(options)}
+      render :partial => 'alchemy/search/form', :locals => {:options => default_options.merge(options), :search_result_page => find_search_result_page}
     end
 
-    # Renders the search +results+ partial from +app/views/alchemy/search/+
+    # Renders the search results partial within +app/views/alchemy/search/_results.html+
+    #
+    # @option options show_result_count [Boolean] (true) Should the count of results be displayed or not?
+    # @option options show_heading [Boolean] (true) Should the heading be displayed or not?
+    #
     def render_search_results(options={})
       default_options = {
         :show_result_count => true,

data/app/helpers/alchemy/url_helper.rb

@@ -76,6 +76,7 @@ module Alchemy
 
     # Returns the correct params-hash for passing to show_page_path
     def show_page_path_params(page, optional_params={})
+      raise ArgumentError, 'Page is nil' if page.nil?
       url_params = {:level1 => nil, :level2 => nil, :level3 => nil, :urlname => page.urlname}
       url_params.update(optional_params)
       url_params.update(params_for_nested_url(page)) if configuration(:url_nesting)

data/app/models/alchemy/content.rb

@@ -7,8 +7,7 @@ module Alchemy
       :essence_id,
       :essence_type,
       :ingredient,
-      :name,
-      :position
+      :name
     )
 
     belongs_to :essence, :polymorphic => true, :dependent => :destroy

data/app/models/alchemy/element.rb

@@ -1,7 +1,7 @@
 module Alchemy
   class Element < ActiveRecord::Base
 
-    FORBIDDEN_DEFINITION_ATTRIBUTES = %w(contents available_contents amount picture_gallery taggable)
+    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
@@ -12,7 +12,6 @@ module Alchemy
       :folded,
       :name,
       :page_id,
-      :position,
       :public,
       :tag_list,
       :unique
@@ -29,6 +28,7 @@ module Alchemy
 
     validates_uniqueness_of :position, :scope => [:page_id, :cell_id], :if => lambda { |e| e.position != nil }
     validates_presence_of :name, :on => :create
+    validates_format_of :name, :on => :create, :with => /\A[a-z0-9_-]+\z/
 
     attr_accessor :create_contents_after_create
 
@@ -37,6 +37,7 @@ module Alchemy
     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)) }
@@ -510,6 +511,50 @@ module Alchemy
       description['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
+    #
+    # 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
+    #     hint: true
+    #
+    #   # config/locales/de.yml
+    #     de:
+    #       element_hints:
+    #         headline: Lorem ipsum
+    #
+    # == 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?
+    end
+
   private
 
     # creates the contents for this element as described in the elements.yml

data/app/models/alchemy/language.rb

@@ -9,17 +9,19 @@ module Alchemy
       :public,
       :default,
       :country_code,
-      :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 => :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? }
@@ -30,18 +32,29 @@ module Alchemy
 
     scope :published, where(:public => true)
 
-    def self.all_for_created_language_trees
-      find(Page.language_roots.collect(&:language_id))
-    end
+    # multi-site support
+    scope :on_site, lambda { |s| s.present? ? where(site_id: s) : scoped }
+    default_scope { on_site(Site.current) }
 
-    def self.all_codes_for_published
-      self.published.collect(&:code)
-    rescue
-      []
-    end
+    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))
+      end
+
+      def all_codes_for_published
+        published.collect(&:code)
+      rescue
+        []
+      end
+
+      def get_default
+        where(default: true).first
+      end
 
-    def self.get_default
-      self.find_by_default(true)
     end
 
     def label(attrib)
@@ -54,7 +67,7 @@ module Alchemy
 
     include Code
 
-    private
+  private
 
     def publicity_of_default_language
       if self.default? && !self.public?
@@ -75,7 +88,7 @@ module Alchemy
     end
 
     def remove_old_default
-      lang = Language.get_default
+      lang = Language.on_site(site).get_default
       return true if lang.nil?
       lang.default = false
       lang.save(:validate => false)

data/app/models/alchemy/page.rb

@@ -28,7 +28,6 @@ module Alchemy
       :name,
       :page_layout,
       :parent_id,
-      :position,
       :public,
       :restricted,
       :robot_index,
@@ -52,6 +51,7 @@ module Alchemy
     has_and_belongs_to_many :to_be_sweeped_elements, :class_name => 'Alchemy::Element', :uniq => true, :join_table => 'alchemy_elements_alchemy_pages'
     belongs_to :language
 
+    validates_presence_of :language, :on => :create, :unless => :root
     validates_presence_of :name
     validates_presence_of :page_layout, :unless => :systempage?
     validates_presence_of :parent_id, :if => proc { Page.count > 1 }

data/app/models/alchemy/picture.rb

@@ -6,27 +6,28 @@ module Alchemy
     has_many :elements, :through => :contents
     has_many :pages, :through => :elements
 
-    acts_as_fleximage do
-      image_directory 'uploads/pictures'
-      image_storage_format Config.get(:image_store_format).to_sym
-      require_image true
-      missing_image_message I18n.t("missing_image")
-      invalid_image_message I18n.t("not a valid image")
-      output_image_jpg_quality Config.get(:output_image_jpg_quality) if Config.get(:image_output_format) == "jpg"
-      unless Config.get(:preprocess_image_resize).blank?
-        preprocess_image do |image|
-          image.resize Config.get(:preprocess_image_resize)
-        end
+    # Raise error, if picture is in use (aka. assigned to an EssencePicture)
+    #
+    # === CAUTION:
+    # This HAS to be placed for Dragonfly's class methods, to ensure this runs before Dragonfly's before_destroy callback.
+    #
+    before_destroy :unless => :deletable? do
+      raise PictureInUseError, I18n.t(:cannot_delete_picture_notice) % { :name => name }
+    end
+
+    image_accessor :image_file do
+      if Config.get(:preprocess_image_resize).present?
+        after_assign { |a| a.process!(:resize, Config.get(:preprocess_image_resize)) }
       end
     end
 
+    validates_presence_of :image_file
+    validates_property :format, :of => :image_file, :in => Config.get('uploader')['allowed_filetypes']['pictures'].map(&:to_sym), :message => I18n.t("not a valid image")
+
     acts_as_taggable
 
     attr_accessible(
       :image_file,
-      :image_filename,
-      :image_height,
-      :image_width,
       :name,
       :tag_list,
       :upload_hash
@@ -35,6 +36,7 @@ module Alchemy
     stampable(:stamper_class_name => 'Alchemy::User')
 
     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)
@@ -60,32 +62,31 @@ module Alchemy
     end
 
     def suffix
-      if image_filename =~ /\./
-        image_filename.split('.').last.downcase
-      else
-        ""
-      end
+      image_file.ext
     end
 
     def humanized_name
-      return "" if image_filename.blank?
-      (image_filename.downcase.gsub(/\.#{::Regexp.quote(suffix)}$/, '')).humanize
+      return "" if image_file_name.blank?
+      (image_file_name.downcase.gsub(/\.#{::Regexp.quote(suffix)}$/, '')).humanize
     end
 
     # Returning true if picture's width is greater than it's height
     def landscape_format?
-      return (self.image_width > self.image_height) ? true : false
+      image_file.landscape?
     end
+    alias_method :landscape?, :landscape_format?
 
     # Returning true if picture's width is smaller than it's height
     def portrait_format?
-      return (self.image_width < self.image_height) ? true : false
+      image_file.portrait?
     end
+    alias_method :portrait?, :portrait_format?
 
     # Returning true if picture's width and height is equal
     def square_format?
-      return (self.image_width == self.image_height) ? true : false
+      image_file.aspect_ratio == 1.0
     end
+    alias_method :square?, :square_format?
 
     # Returns the default centered image mask for a given size
     def default_mask(size)
@@ -93,24 +94,24 @@ module Alchemy
       width = size.split('x')[0].to_i
       height = size.split('x')[1].to_i
       if (width > height)
-        zoom_factor = image_width.to_f / width
+        zoom_factor = image_file_width.to_f / width
         mask_height = (height * zoom_factor).round
         x1 = 0
-        x2 = image_width
-        y1 = (image_height - mask_height) / 2
+        x2 = image_file_width
+        y1 = (image_file_height - mask_height) / 2
         y2 = y1 + mask_height
       elsif (width == 0 && height == 0)
         x1 = 0
-        x2 = image_width
+        x2 = image_file_width
         y1 = 0
-        y2 = image_height
+        y2 = image_file_height
       else
-        zoom_factor = image_height.to_f / height
+        zoom_factor = image_file_height.to_f / height
         mask_width = (width * zoom_factor).round
-        x1 = (image_width - mask_width) / 2
+        x1 = (image_file_width - mask_width) / 2
         x2 = x1 + mask_width
         y1 = 0
-        y2 = image_height
+        y2 = image_file_height
       end
       {
         :x1 => x1,
@@ -141,6 +142,14 @@ module Alchemy
       pages.any? && pages.not_restricted.blank?
     end
 
+    def deletable?
+      !essence_pictures.any?
+    end
+
+    def image_file_dimensions
+      "#{image_file_width} x #{image_file_height}"
+    end
+
     # Returns a security token for signed picture rendering requests.
     #
     # Pass a params hash containing:
@@ -149,21 +158,17 @@ module Alchemy
     #   crop       [Boolean] (Optional)
     #   crop_from  [String]  (Optional)
     #   crop_size  [String]  (Optional)
+    #   quality    [Integer] (Optional)
     #
     # to sign them.
     #
     def security_token(params = {})
       @params = params.stringify_keys
-      @params.update({'crop' => @params['crop'] ? 'crop' : nil})
-      Digest::SHA1.hexdigest(secured_params)[0..15]
-    end
-
-  private
-
-    def secured_params
-      secret = Rails.configuration.secret_token
-      [id, @params['size'], @params['crop'], @params['crop_from'], @params['crop_size'], secret].join('-')
+      @params.update({'crop' => @params['crop'] ? 'crop' : nil, 'id' => self.id})
+      @params.delete_if { |k,v| v.nil? }
+      PictureAttributes.secure(@params)
     end
 
   end
+  class PictureInUseError < StandardError; end
 end

data/app/models/alchemy/site.rb

@@ -0,0 +1,44 @@
+module Alchemy
+  class Site < ActiveRecord::Base
+    cattr_accessor :current
+
+    attr_accessible :host, :name, :public
+
+    # validations
+    validates_presence_of :host
+    validates_uniqueness_of :host
+
+    # associations
+    has_many :languages
+
+    scope :published, where(public: true)
+
+    # Returns true if this site is the current site
+    def current?
+      self.class.current == self
+    end
+
+    class << self
+      def default
+        Site.first
+      end
+    end
+
+    before_create do
+      # If no languages are present, create a default language based
+      # on the host app's Alchemy configuration.
+
+      if languages.empty?
+        default_language = Alchemy::Config.get(:default_language)
+        languages.build(
+          name:           default_language['name'],
+          language_code:  default_language['code'],
+          frontpage_name: default_language['frontpage_name'],
+          page_layout:    default_language['page_layout'],
+          public:         true,
+          default:        true
+        )
+      end
+    end
+  end
+end