alchemy_cms 2.9.1 → 3.0.0.rc5

data/lib/alchemy/essence.rb

@@ -29,14 +29,21 @@ module Alchemy #:nodoc:
         }.update(options)
 
         class_eval <<-EOV
-          attr_accessor :validation_errors
-          attr_accessible :ingredient
+          attr_writer :validation_errors
           include Alchemy::Essence::InstanceMethods
           stampable stamper_class_name: Alchemy.user_class_name
-          validate :essence_validations, :on => :update
-          has_many :contents, :as => :essence
-          has_many :elements, :through => :contents
-          has_many :pages, :through => :elements
+          validate :validate_ingredient, :on => :update, :if => 'validations.any?'
+
+          has_one :content, :as => :essence
+          has_one :element, :through => :content
+          has_one :page,    :through => :element
+
+          scope :available,    -> { joins(:element).merge(Element.available) }
+          scope :from_element, ->(name) { joins(:element).where(alchemy_elements: { name: name }) }
+
+          delegate :public?, to: :element
+
+          after_update :touch_content
 
           def acts_as_essence_class
             #{self.name}
@@ -64,20 +71,24 @@ module Alchemy #:nodoc:
       #
       # Essence validations can be set inside the config/elements.yml file.
       #
-      # Currently supported validations are:
+      # Supported validations are:
       #
       # * presence
-      # * format
       # * uniqueness
+      # * format
       #
-      # If you want to validate the format you must additionally pass validate_format_as or validate_format_with:
+      # format needs to come with a regex or a predefined matcher string as its value.
+      # There are already predefined format matchers listed in the config/alchemy/config.yml file.
+      # It is also possible to add own format matchers there.
       #
-      # * validate_format_with has to be regex
-      # * validate_format_as can be one of:
-      # ** url
-      # ** email
+      # Example of format matchers in config/alchemy/config.yml:
       #
-      # Example:
+      # format_matchers:
+      #   email: !ruby/regexp '/\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/'
+      #   url:   !ruby/regexp '/\A[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?\z/ix'
+      #   ssl:   !ruby/regexp '/https:\/\/[\S]+/'
+      #
+      # Example of an element definition with essence validations:
       #
       #   - name: person
       #     contents:
@@ -86,48 +97,68 @@ module Alchemy #:nodoc:
       #       validate: [presence]
       #     - name: email
       #       type: EssenceText
-      #       validate: [format]
-      #       validate_format_as: 'email'
+      #       validate: [format: 'email']
       #     - name: homepage
       #       type: EssenceText
-      #       validate: [format]
-      #       validate_format_with: '^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$'
+      #       validate: [format: !ruby/regexp '^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$']
+      #
+      # Example of an element definition with chained validations.
+      #
+      #   - name: person
+      #     contents:
+      #     - name: name
+      #       type: EssenceText
+      #       validate: [presence, uniqueness, format: 'name']
       #
-      def essence_validations
-        self.validation_errors ||= []
-        return true if description.blank? || description['validate'].blank?
-        description['validate'].each do |validation|
-          if validation == 'presence' && ingredient.blank?
-            self.validation_errors << :blank
-          elsif validation == 'format'
-            if description['validate_format_as'].blank? && !description['validate_format_with'].blank?
-              matcher = Regexp.new(description['validate_format_with'])
-            elsif !description['validate_format_as'].blank? && description['validate_format_with'].blank?
-              case description['validate_format_as']
-              when 'email'
-              then
-                matcher = Alchemy::Config.get(:email_regexp)
-              when 'url'
-              then
-                matcher = /^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix
-              else
-                raise "No validation format matcher found for #{description['validate_format_as']}"
-              end
-            else
-              raise 'No validation format matcher given'
-            end
-            if ingredient.to_s.match(matcher).nil?
-              self.validation_errors << :invalid
-            end
-          elsif validation == 'uniqueness' && !acts_as_essence_class.send("find_by_#{ingredient_column}", ingredient).blank?
-            self.validation_errors << :taken
+      def validate_ingredient
+        validations.each do |validation|
+          if validation.respond_to?(:keys)
+            validation.map {|key,value| self.send("validate_#{key}", validation) }
+          else
+            self.send("validate_#{validation}")
           end
         end
-        self.validation_errors.each do |validation_error|
-          self.errors.add(self.ingredient_column, validation_error)
+      end
+
+      def validations
+        @validations ||= description.present? ? description['validate'] || [] : []
+      end
+
+      def validation_errors
+        @validation_errors ||= []
+      end
+
+      def validate_presence
+        if ingredient.blank?
+          errors.add(ingredient_column, :blank)
+          validation_errors << :blank
+        end
+      end
+
+      def validate_uniqueness
+        return if !public?
+        if duplicates.any?
+          errors.add(ingredient_column, :taken)
+          validation_errors << :taken
         end
       end
 
+      def validate_format(validation)
+        matcher = Config.get('format_matchers')["#{validation['format']}"] || validation['format']
+        if ingredient.to_s.match(Regexp.new(matcher)).nil?
+          errors.add(ingredient_column, :invalid)
+          validation_errors << :invalid
+        end
+      end
+
+      def duplicates
+        acts_as_essence_class
+          .available
+          .from_element(element.name)
+          .where("#{ingredient_column}" => ingredient)
+          .where.not(id: self.id)
+      end
+
       # Returns the value stored from the database column that is configured as ingredient column.
       def ingredient
         if self.respond_to?(ingredient_column)
@@ -153,21 +184,10 @@ module Alchemy #:nodoc:
         element.content_descriptions.detect { |c| c['name'] == self.content.name } || {}
       end
 
-      # Returns the Content Essence is in
-      def content
-        Alchemy::Content.find_by_essence_type_and_essence_id(acts_as_essence_class.to_s, self.id)
-      end
-
-      # Returns the Element Essence is in
-      def element
+      # Touch content. Called after update.
+      def touch_content
         return nil if content.nil?
-        content.element
-      end
-
-      # Returns the Page Essence is on
-      def page
-        return nil if element.nil?
-        element.page
+        content.touch
       end
 
       # Returns the first x (default 30) characters of ingredient for the Element#preview_text method.
@@ -185,7 +205,7 @@ module Alchemy #:nodoc:
       end
 
       def acts_as_essence?
-        !acts_as_essence_class.blank?
+        acts_as_essence_class.present?
       end
 
       def to_partial_path

data/lib/alchemy/forms/builder.rb

@@ -0,0 +1,23 @@
+module Alchemy
+  module Forms
+    class Builder < SimpleForm::FormBuilder
+
+      # Renders a simple_form input, but uses input alchemy_wrapper
+      #
+      def input(attribute_name, options = {}, &block)
+        options[:wrapper] = :alchemy
+        super
+      end
+
+      # Renders a button tag wrapped in a div with 'submit' class.
+      #
+      def submit(label, options = {})
+        options = {class: 'submit'}.update(options[:wrapper_html] || {})
+        template.content_tag('div', options) do
+          template.content_tag('button', label, options[:input_html])
+        end
+      end
+
+    end
+  end
+end

data/lib/alchemy/hints.rb

@@ -0,0 +1,57 @@
+module Alchemy
+  module Hints
+
+    # Returns a hint
+    #
+    # 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: hint_translation_scope)
+      else
+        hint
+      end
+    end
+
+    # Returns true if the element has a hint
+    def has_hint?
+      hint.present?
+    end
+
+    private
+
+    def hint_translation_scope
+      "#{self.class.model_name.to_s.demodulize.downcase}_hints"
+    end
+
+  end
+end

data/lib/alchemy/locale.rb

@@ -0,0 +1,63 @@
+module Alchemy
+  module Locale
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :set_translation
+    end
+
+    private
+
+    # Sets Alchemy's GUI translation.
+    #
+    #   * If one passed a locale via +params[:locale]+ it uses this.
+    #   * Or it tries to get users preffered language.
+    #   * If not found it guesses the language from the browser locale.
+    #   * If that also fails it takes the default.
+    #
+    # It respects the default translation from your +config/application.rb+ +default_locale+ config option.
+    #
+    def set_translation
+      if locale_change_needed?
+        ::I18n.locale = session[:alchemy_locale] = locale_from_params ||
+          locale_from_user || locale_from_browser || ::I18n.default_locale
+      else
+        ::I18n.locale = session[:alchemy_locale]
+      end
+    end
+
+    # Checks if we need to change to locale or not.
+    def locale_change_needed?
+      params[:locale].present? || session[:alchemy_locale].blank?
+    end
+
+    # Try to get the locale from +params[:locale]+.
+    def locale_from_params
+      return if params[:locale].blank?
+      if ::I18n.available_locales.include?(params[:locale].to_sym)
+        params[:locale]
+      end
+    end
+
+    # Try to get the locale from user settings.
+    def locale_from_user
+      return if !current_alchemy_user
+      if user_has_preferred_language?
+        current_alchemy_user.language
+      end
+    end
+
+    # Checks if the +current_alchemy_user+ has a preferred language set or not.
+    def user_has_preferred_language?
+      return if !current_alchemy_user
+      current_alchemy_user.respond_to?(:language) &&
+        current_alchemy_user.language.present?
+    end
+
+    # Try to get the locale from browser headers.
+    def locale_from_browser
+      request.env['HTTP_ACCEPT_LANGUAGE'].try(:scan, /\A[a-z]{2}/).try(:first)
+    end
+
+  end
+end

data/lib/alchemy/modules.rb

@@ -8,6 +8,23 @@ module Alchemy
       base.send :helper_method, :alchemy_modules, :module_definition_for
     end
 
+    # Register a Alchemy module.
+    #
+    # A module is a Hash that must have at least a name and a navigation key
+    # that has a controller and action name.
+    #
+    # == Example:
+    #
+    #     name: 'module',
+    #     navigation: {
+    #       controller: 'admin/controller_name',
+    #       action: 'index'
+    #     }
+    #
+    def self.register_module(module_definition)
+      @@alchemy_modules << module_definition.stringify_keys
+    end
+
     # Get the module definition for given module name
     #
     # You can also pass a hash of an module definition.
@@ -26,23 +43,6 @@ module Alchemy
       end
     end
 
-    # Register a Alchemy module.
-    #
-    # A module is a Hash that must have at least a name and a navigation key
-    # that has a controller and action name.
-    #
-    # == Example:
-    #
-    #     name: 'module',
-    #     navigation: {
-    #       controller: 'admin/controller_name',
-    #       action: 'index'
-    #     }
-    #
-    def self.register_module(module_definition)
-      @@alchemy_modules << module_definition.stringify_keys
-    end
-
     private
 
     def alchemy_module_navigation(alchemy_module)

data/lib/alchemy/mount_point.rb

@@ -10,7 +10,7 @@ module Alchemy
     #
     def self.get(remove_leading_slash_if_blank = true)
       if self.mount_point == "/" && remove_leading_slash_if_blank
-        self.mount_point.gsub(/^\/$/, '')
+        self.mount_point.gsub(/\A\/\z/, '')
       else
         self.mount_point
       end

data/lib/alchemy/permissions.rb

@@ -0,0 +1,199 @@
+module Alchemy
+
+  # ## Alchemy's permissions
+  #
+  # These are CanCan abilities, but to prevent any naming collusions we named it permissions.
+  #
+  # Alchemy user rules are modules that can be included in your app's/engine's Ability class.
+  #
+  # ### Example:
+  #
+  #     # app/models/ability.rb
+  #     class Ability
+  #       include CanCan::Ability
+  #       include Alchemy::Permissions::EditorUser
+  #
+  #       def initialize(user)
+  #         return if user.nil?
+  #         @user ||= user
+  #         if @user.has_role?(:demo)
+  #           alchemy_editor_rules # alchemy editor roles
+  #           # your own rules
+  #         end
+  #       end
+  #
+  #     end
+  #
+  class Permissions
+    include CanCan::Ability
+
+    def initialize(user)
+      set_action_aliases
+      @user ||= user
+      @user ? user_role_rules : alchemy_guest_user_rules
+    end
+
+    module GuestUser
+      def alchemy_guest_user_rules
+        can([:show, :download], Alchemy::Attachment) { |a| !a.restricted? }
+        can :show,              Alchemy::Element,    public: true, page: { restricted: false }
+        can :show,              Alchemy::Page,       restricted: false, public: true
+        can :see,               Alchemy::Page,       restricted: false, visible: true
+        can([:show, :download], Alchemy::Picture)    { |p| !p.restricted? }
+      end
+    end
+
+    # == Member rules
+    #
+    # Includes guest users rules
+    #
+    module MemberUser
+      include Alchemy::Permissions::GuestUser
+
+      def alchemy_member_rules
+        alchemy_guest_user_rules
+
+        # Resources
+        can [:show, :download], Alchemy::Attachment
+        can :show,              Alchemy::Element,   public: true, page: { restricted: true }
+        can :show,              Alchemy::Page,      public: true
+        can :see,               Alchemy::Page,      restricted: true, visible: true
+        can [:show, :download], Alchemy::Picture
+        can [:read, :update],   Alchemy.user_class, id: @user.id
+      end
+    end
+
+    # == Author rules
+    #
+    # Includes member users rules
+    #
+    module AuthorUser
+      include Alchemy::Permissions::MemberUser
+
+      def alchemy_author_rules
+        alchemy_member_rules
+
+        # Navigation
+        can :index, [
+          :alchemy_admin_attachments,
+          :alchemy_admin_dashboard,
+          :alchemy_admin_layoutpages,
+          :alchemy_admin_pages,
+          :alchemy_admin_pictures,
+          :alchemy_admin_tags,
+          :alchemy_admin_users
+        ]
+
+        # Controller actions
+        can [:info, :help],             :alchemy_admin_dashboard
+        can :index,                     :trash
+
+        # Resources
+        can [:read, :download],         Alchemy::Attachment
+        can :manage,                    Alchemy::Clipboard
+        can :manage,                    Alchemy::Content
+        can :manage,                    Alchemy::Element
+        can :manage,                    Alchemy::EssenceFile
+        can :manage,                    Alchemy::EssencePicture
+        can :edit_content,              Alchemy::Page
+        can [:read, :thumbnail, :info], Alchemy::Picture
+        can [:read, :autocomplete],     Alchemy::Tag
+      end
+    end
+
+    # == Editor rules
+    #
+    # Includes author rules
+    #
+    module EditorUser
+      include Alchemy::Permissions::AuthorUser
+
+      def alchemy_editor_rules
+        alchemy_author_rules
+
+        # Navigation
+        can :index, [
+          :alchemy_admin_languages,
+          :alchemy_admin_users
+        ]
+
+        # Controller actions
+        can :clear,  :trash
+
+        # Resources
+        can [
+          :copy,
+          :copy_language_tree,
+          :create,
+          :destroy,
+          :flush,
+          :order,
+          :sort,
+          :switch_language
+        ], Alchemy::Page
+        can :manage, Alchemy::Picture
+        can :manage, Alchemy::Attachment
+        can :read,   Alchemy.user_class
+        can :manage, Alchemy::Tag
+      end
+    end
+
+    # == Admin rules
+    #
+    # Includes editor rules
+    #
+    module AdminUser
+      include Alchemy::Permissions::EditorUser
+
+      def alchemy_admin_rules
+        alchemy_editor_rules
+
+        # Navigation
+        can :index,                 [:alchemy_admin_sites]
+
+        # Controller actions
+        can [:info, :update_check], :alchemy_admin_dashboard
+
+        # Resources
+        can :manage,                Alchemy.user_class
+        can :manage,                Alchemy::Language
+        can :manage,                Alchemy::Site
+      end
+    end
+
+    private
+
+    def user_role_rules
+      return [] if @user.alchemy_roles.nil?
+      @user.alchemy_roles.each do |role|
+        exec_role_rules(role) if @user.alchemy_roles.include?(role)
+      end
+    end
+
+    def exec_role_rules(role)
+      meth = :"alchemy_#{role}_rules"
+      send(meth) if respond_to?(meth)
+    end
+
+    def set_action_aliases
+      alias_action :configure,
+        :fold,
+        :info,
+        :link,
+        :publish,
+        :read,
+        :update,
+        :unlock,
+        :visit,
+        to: :edit_content
+    end
+
+    # Include the role specific permissions.
+    include GuestUser
+    include MemberUser
+    include AuthorUser
+    include EditorUser
+    include AdminUser
+
+  end
+end