alchemy_cms 3.2.1 → 3.3.0.rc1

data/lib/alchemy/on_page_layout/callbacks_runner.rb

@@ -0,0 +1,34 @@
+module Alchemy
+  module OnPageLayout
+    # Runs OnPageLayout callbacks
+    #
+    # Included in +Alchemy::PagesController+ and +Alchemy::Admin::PagesController+
+    #
+    # @see OnPageLayout in order to learn how to define +on_page_layout+ callbacks.
+    #
+    module CallbacksRunner
+      private
+
+      def run_on_page_layout_callbacks?
+        OnPageLayout.callbacks.present?
+      end
+
+      def run_on_page_layout_callbacks
+        OnPageLayout.callbacks.each do |page_layout, callbacks|
+          next unless call_page_layout_callback_for?(page_layout)
+          callbacks.each do |callback|
+            if callback.respond_to?(:call)
+              instance_eval(&callback)
+            else
+              send(callback)
+            end
+          end
+        end
+      end
+
+      def call_page_layout_callback_for?(page_layout)
+        page_layout.to_sym == :all || @page.page_layout.to_sym == page_layout.to_sym
+      end
+    end
+  end
+end

data/lib/alchemy/page_layout.rb

@@ -1,22 +1,21 @@
 module Alchemy
   class PageLayout
     class << self
-
       # Returns all page layouts.
       #
       # They are defined in +config/alchemy/page_layout.yml+ file.
       #
       def all
-        @definitions ||= read_layouts_file
+        @definitions ||= read_definitions_file
       end
 
-      # Add additional page layout definitions to collection.
+      # Add additional page definitions to collection.
       #
       # Useful for extending the page layouts from an Alchemy module.
       #
       # === Usage Example
       #
-      #   Call +Alchemy::PageLayout.add(your_layout_definition)+ in your engine.rb file.
+      #   Call +Alchemy::PageLayout.add(your_definition)+ in your engine.rb file.
       #
       # @param [Array || Hash]
       #   You can pass a single layout definition as Hash, or a collection of page layouts as Array.
@@ -32,31 +31,32 @@ module Alchemy
         end
       end
 
-      # Returns one page layout description by given name.
+      # Returns one page definition by given name.
       #
       def get(name)
         return {} if name.blank?
-        all.detect { |a| a['name'].downcase == name.downcase }
+        all.detect { |a| a['name'].casecmp(name) == 0 }
       end
 
       def get_all_by_attributes(attributes)
         return [] if attributes.blank?
-        if attributes.class.name == 'Hash'
+
+        if attributes.is_a? Hash
           layouts = []
           attributes.stringify_keys.each do |key, value|
-            result = all.select { |a| a[key].to_s.downcase == value.to_s.downcase if a.has_key?(key) }
+            result = all.select { |l| l.key?(key) && l[key].to_s.casecmp(value.to_s) == 0 }
             layouts += result unless result.empty?
           end
-          return layouts
+          layouts
         else
-          return []
+          []
         end
       end
 
       # Returns page layouts ready for Rails' select form helper.
       #
       def layouts_for_select(language_id, only_layoutpages = false)
-        @map_array = [[I18n.t('Please choose'), '']]
+        @map_array = [[Alchemy.t('Please choose'), '']]
         mapped_layouts_for_select(selectable_layouts(language_id, only_layoutpages))
       end
 
@@ -83,22 +83,22 @@ module Alchemy
       #
       def selectable_layouts(language_id, only_layoutpages = false)
         @language_id = language_id
-        all.select { |layout|
+        all.select do |layout|
           if only_layoutpages
             layout['layoutpage'] && layout_available?(layout)
           else
             !layout['layoutpage'] && layout_available?(layout)
           end
-        }
+        end
       end
 
       # Returns all names of elements defined in given page layout.
       #
       def element_names_for(page_layout)
-        if layout_description = get(page_layout)
-          layout_description.fetch('elements', [])
+        if definition = get(page_layout)
+          definition.fetch('elements', [])
         else
-          Rails.logger.warn "\n+++ Warning: No Layout Description for #{page_layout} found! in page_layouts.yml\n"
+          Rails.logger.warn "\n+++ Warning: No layout definition for #{page_layout} found! in page_layouts.yml\n"
           return []
         end
       end
@@ -107,19 +107,19 @@ module Alchemy
       #
       # === Translation example
       #
-      #   de:
+      #   en:
       #     alchemy:
       #       page_layout_names:
-      #         products_overview: Produktübersicht
+      #         products_overview: Products Overview
       #
       # @param [String]
       #   The layout name
       #
       def human_layout_name(layout)
-        I18n.t(layout, scope: 'page_layout_names', default: layout.to_s.humanize)
+        Alchemy.t(layout, scope: 'page_layout_names', default: layout.to_s.humanize)
       end
 
-    private
+      private
 
       # Returns true if the given layout is unique and not already taken or it should be hidden.
       #
@@ -150,13 +150,13 @@ module Alchemy
       #     page_layouts: [default_intro]
       #
       def available_on_site?(layout)
-        Site.current.layout_definition.blank? || Site.current.layout_definition.fetch('page_layouts', []).include?(layout['name'])
+        Site.current.definition.blank? || Site.current.definition.fetch('page_layouts', []).include?(layout['name'])
       end
 
       # Reads the layout definitions from +config/alchemy/page_layouts.yml+.
       #
-      def read_layouts_file
-        if File.exists?(layouts_file_path)
+      def read_definitions_file
+        if File.exist?(layouts_file_path)
           YAML.load(ERB.new(File.read(layouts_file_path)).result) || []
         else
           raise LoadError, "Could not find page_layouts.yml file! Please run `rails generate alchemy:scaffold`"
@@ -177,7 +177,6 @@ module Alchemy
         end
         @map_array
       end
-
     end
   end
 end

data/lib/alchemy/paths.rb

@@ -0,0 +1,32 @@
+# Provides admin interface routing configuration accessors.
+#
+# Alchemy has some defaults for admin path and admin constraints:
+#
+# +Alchemy.admin_path defaults to +'/admin'+
+# +Alchemy.admin_constraints defaults to +{}+
+#
+# Anyway, you can tell Alchemy about your routing configuration:
+#
+#   1. The path to the admin panel - @see: Alchemy.admin_path
+#   2. The constraints for the admin panel (like subdomain) - @see: Alchemy.admin_constraints
+#
+# A word of caution: you need to know what you are doing if you set admin_path to ''. This can cause
+# routing name clashes, e.g. a page named 'dashboard' will clash with the Alchemy dashboard.
+#
+# == Example
+#
+# If you do not wish to use the default admin interface routing ('example.com/admin/')
+# and prefer e.g. 'hidden.example.com/backend/', those are the settings you need:
+#
+#     # config/initializers/alchemy.rb
+#     Alchemy.admin_path = '/backend'
+#     Alchemy.admin_constraints = {subdomain: 'hidden'}
+#
+module Alchemy
+  mattr_accessor :admin_path, :admin_constraints
+
+  # Defaults
+  #
+  @@admin_path = '/admin'
+  @@admin_constraints = {}
+end

data/lib/alchemy/permissions.rb

@@ -1,5 +1,4 @@
 module Alchemy
-
   # ## Alchemy's permissions
   #
   # These are CanCan abilities, but to prevent any naming collusions we named it permissions.
@@ -21,7 +20,6 @@ module Alchemy
   #           # your own rules
   #         end
   #       end
-  #
   #     end
   #
   class Permissions
@@ -36,17 +34,20 @@ module Alchemy
     module GuestUser
       def alchemy_guest_user_rules
         can([:show, :download], Alchemy::Attachment) { |a| !a.restricted? }
-        can :read,              Alchemy::Content,    Alchemy::Content.available.not_restricted do |c|
+        can :see,               Alchemy::Page,       restricted: false, visible: true
+        can(:display,           Alchemy::Picture)    { |p| !p.restricted? }
+
+        can :read, Alchemy::Content, Alchemy::Content.available.not_restricted do |c|
           c.public? && !c.restricted? && !c.trashed?
         end
-        can :read,              Alchemy::Element,    Alchemy::Element.available.not_restricted do |e|
+
+        can :read, Alchemy::Element, Alchemy::Element.available.not_restricted do |e|
           e.public? && !e.restricted? && !e.trashed?
         end
-        can :read,              Alchemy::Page,       Alchemy::Page.published.not_restricted do |p|
+
+        can :read, Alchemy::Page, Alchemy::Page.published.not_restricted do |p|
           p.public? && !p.restricted?
         end
-        can :see,               Alchemy::Page,       restricted: false, visible: true
-        can(:display,           Alchemy::Picture)    { |p| !p.restricted? }
       end
     end
 
@@ -62,18 +63,17 @@ module Alchemy
 
         # Resources
         can [:show, :download], Alchemy::Attachment
-        can :read,              Alchemy::Content,   Alchemy::Content.available do |c|
+        can :read,              Alchemy::Page,      Alchemy::Page.published, &:public?
+        can :see,               Alchemy::Page,      restricted: true, visible: true
+        can :display,           Alchemy::Picture
+
+        can :read, Alchemy::Content, Alchemy::Content.available do |c|
           c.public? && !c.trashed?
         end
-        can :read,              Alchemy::Element,   Alchemy::Element.available do |e|
+
+        can :read, Alchemy::Element, Alchemy::Element.available do |e|
           e.public? && !e.trashed?
         end
-        can :read,              Alchemy::Page,      Alchemy::Page.published do |p|
-          p.public?
-        end
-        can :see,               Alchemy::Page,      restricted: true, visible: true
-        can :display,           Alchemy::Picture
-        can [:read, :update],   Alchemy.user_class, id: @user.id
       end
     end
 
@@ -104,6 +104,7 @@ module Alchemy
         can :manage,                :alchemy_admin_clipboard
         can :index,                 :trash
         can :edit,                  :alchemy_admin_layoutpages
+        can :tree,                  :alchemy_admin_pages
 
         # Resources
         can [:read, :download],     Alchemy::Attachment
@@ -113,7 +114,7 @@ module Alchemy
         can :manage,                Alchemy::EssencePicture
         can :manage,                Alchemy::LegacyPageUrl
         can :edit_content,          Alchemy::Page
-        can [:read, :info],         Alchemy::Picture
+        can :read,                  Alchemy::Picture
         can [:read, :autocomplete], Alchemy::Tag
       end
     end
@@ -135,7 +136,7 @@ module Alchemy
         ]
 
         # Controller actions
-        can :clear,  :trash
+        can :clear, :trash
 
         # Resources
         can [
@@ -149,10 +150,11 @@ module Alchemy
           :sort,
           :switch_language
         ], Alchemy::Page
+
         can :manage, Alchemy::Picture
         can :manage, Alchemy::Attachment
-        can :read,   Alchemy.user_class
         can :manage, Alchemy::Tag
+        can :index,  Alchemy::Language
       end
     end
 
@@ -173,7 +175,6 @@ module Alchemy
         can [:info, :update_check], :alchemy_admin_dashboard
 
         # Resources
-        can :manage,                Alchemy.user_class
         can :manage,                Alchemy::Language
         can :manage,                Alchemy::Site
       end
@@ -216,6 +217,5 @@ module Alchemy
     include AuthorUser
     include EditorUser
     include AdminUser
-
   end
 end

data/lib/alchemy/picture_attributes.rb

@@ -2,11 +2,9 @@ module Alchemy
   # Provides methods to secure your picture attributes against DOS attacks.
   #
   class PictureAttributes
-
     SECURE_ATTRIBUTES = %w(id size crop crop_from crop_size quality upsample).freeze
 
     class << self
-
       # Secures given attributes
       #
       # @param attributes [Hash]
@@ -23,7 +21,6 @@ module Alchemy
       def joined_attributes(attributes)
         attributes.stringify_keys.values_at(*SECURE_ATTRIBUTES, Rails.configuration.secret_token).join('-')
       end
-
     end
   end
 end

data/lib/alchemy/resource.rb

@@ -1,5 +1,6 @@
-require 'active_support/inflector'
+require 'active_support'
 require 'active_support/core_ext'
+require 'active_support/inflector'
 
 module Alchemy
   # = Alchemy::Resource
@@ -84,20 +85,18 @@ module Alchemy
   #     resource = Resource.new('/admin/tags', {"engine_name"=>"alchemy"}, ActsAsTaggableOn::Tag)
   #
   class Resource
-    attr_accessor :skipped_attributes, :restricted_attributes, :resource_relations, :model_associations
+    attr_accessor :resource_relations, :model_associations
     attr_reader :model
 
     DEFAULT_SKIPPED_ATTRIBUTES = %w(id updated_at created_at creator_id updater_id)
     DEFAULT_SKIPPED_ASSOCIATIONS = %w(creator updater)
 
-    def initialize(controller_path, module_definition=nil, custom_model=nil)
+    def initialize(controller_path, module_definition = nil, custom_model = nil)
       @controller_path = controller_path
       @module_definition = module_definition
-      @model = (custom_model or guess_model_from_controller_path)
-      self.skipped_attributes = model.respond_to?(:skipped_alchemy_resource_attributes) ? model.skipped_alchemy_resource_attributes : DEFAULT_SKIPPED_ATTRIBUTES
-      self.restricted_attributes = model.respond_to?(:restricted_alchemy_resource_attributes) ? model.restricted_alchemy_resource_attributes : []
+      @model = (custom_model || guess_model_from_controller_path)
       if model.respond_to?(:alchemy_resource_relations)
-        if not model.respond_to?(:reflect_on_all_associations)
+        if !model.respond_to?(:reflect_on_all_associations)
           raise MissingActiveRecordAssociation
         end
         store_model_associations
@@ -140,19 +139,18 @@ module Alchemy
     end
 
     def attributes
-      @_attributes ||= self.model.columns.collect do |col|
-        unless self.skipped_attributes.include?(col.name)
-          {
-            name: col.name,
-            type: resource_column_type(col),
-            relation: resource_relation(col.name)
-          }.delete_if { |k, v| v.nil? }
-        end
+      @_attributes ||= model.columns.collect do |col|
+        next if skipped_attributes.include?(col.name)
+        {
+          name: col.name,
+          type: resource_column_type(col),
+          relation: resource_relation(col.name)
+        }.delete_if { |_k, v| v.nil? }
       end.compact
     end
 
     def editable_attributes
-      attributes.reject { |h| self.restricted_attributes.map(&:to_s).include?(h[:name].to_s) }
+      attributes.reject { |h| restricted_attributes.map(&:to_s).include?(h[:name].to_s) }
     end
 
     # Returns all columns that are searchable
@@ -160,15 +158,23 @@ module Alchemy
     # For now it only uses string type columns
     #
     def searchable_attributes
-      self.attributes.select { |a| a[:type].to_sym == :string }
+      attributes.select { |a| string_attribute?(a) } + searchable_relation_attributes?(attributes)
+    end
+
+    # Search field input name
+    #
+    # Joins all searchable attributes into a Ransack compatible search query
+    #
+    def search_field_name
+      searchable_attributes.collect { |a| a[:name] }.join("_or_") + "_cont"
     end
 
     def in_engine?
-      not self.engine_name.nil?
+      !engine_name.nil?
     end
 
     def engine_name
-      @module_definition and @module_definition['engine_name']
+      @module_definition && @module_definition['engine_name']
     end
 
     # Returns a help text for resource's form
@@ -182,13 +188,52 @@ module Alchemy
     #           attribute_name: This is the fancy help text
     #
     def help_text_for(attribute)
-      ::I18n.translate!(attribute[:name], :scope => [:alchemy, :resource_help_texts, resource_name])
+      ::I18n.translate!(attribute[:name], scope: [:alchemy, :resource_help_texts, resource_name])
     rescue ::I18n::MissingTranslationData
       false
     end
 
+    # Return attributes that should be viewable but not editable.
+    #
+    def restricted_attributes
+      if model.respond_to?(:restricted_alchemy_resource_attributes)
+        model.restricted_alchemy_resource_attributes
+      else
+        []
+      end
+    end
+
+    # Return attributes that should neither be viewable nor editable.
+    #
+    def skipped_attributes
+      if model.respond_to?(:skipped_alchemy_resource_attributes)
+        model.skipped_alchemy_resource_attributes
+      else
+        DEFAULT_SKIPPED_ATTRIBUTES
+      end
+    end
+
     private
 
+    def string_attribute?(a)
+      a[:type].to_sym == :string && !a.key?(:relation)
+    end
+
+    def string_attribute_on_relation?(a)
+      a.key?(:relation) && a[:relation][:attr_type].to_sym == :string
+    end
+
+    def searchable_relation_attributes?(attrs)
+      attrs.select { |a| string_attribute_on_relation?(a) }.map { |a| searchable_relation_attribute(a) }
+    end
+
+    def searchable_relation_attribute(a)
+      {
+        name: "#{a[:relation][:model_association].name}_#{a[:relation][:attr_method]}",
+        type: a[:relation][:attr_type]
+      }
+    end
+
     def guess_model_from_controller_path
       resource_array.join('/').classify.constantize
     end
@@ -220,7 +265,7 @@ module Alchemy
         name = name.to_s.gsub(/_id$/, '') # ensure that we don't have an id
         association = association_from_relation_name(name)
         foreign_key = association.options[:foreign_key] || "#{association.name}_id".to_sym
-        self.resource_relations[foreign_key] = options.merge(:model_association => association, :name => name)
+        resource_relations[foreign_key] = options.merge(model_association: association, name: name)
       end
     end
 
@@ -233,6 +278,5 @@ module Alchemy
     def association_from_relation_name(name)
       model_associations.detect { |a| a.name == name.to_sym }
     end
-
   end
 end