alchemy_cms 2.5.3.1 → 2.6.0.rc5

data/lib/alchemy/resource.rb

@@ -2,35 +2,113 @@ require 'active_support/inflector'
 require 'active_support/core_ext'
 
 module Alchemy
+  # = Alchemy::Resource
+  #
+  # Used to DRY up resource like structures in Alchemy's admin backend.
+  # So far Language, User and Tag already uses this.
+  #
+  # It provides convenience methods to create an admin interface without further knowledge about
+  # the model and the controller (it's instantiated with controller_path at least and guesses the model accordingly)
+  #
+  # For examples how to use in controllers see Alchemy::ResourcesController or inherit from it directly.
+  #
+  # == Naming Conventions
+  #
+  # As Rails' form helpers, path helpers, etc. and declarative authorization rely on controller_path even if the model
+  # class is named differently (or sits in another namespace) model and controller are handled separatly here.
+  # Therefore "resource" always refers to the controller_path whereas "model" refers to the model class.
+  #
+  # == Skip attributes
+  #
+  # Usually you don't want your users to edit all attributes provided by a model. Hence some default attributes,
+  # namely id, updated_at, created_at, creator_id and updater_id are not returned by Resource#attributes.
+  #
+  # If you want to skip a different set of attributes just define a skip_attributes class method in your model class
+  # that returns an array of strings: %W[id, updated_at]
+  #
+  # == Resource relations
+  #
+  # Alchemy::Resource can take care of ActiveRecord relations. You will have to announce relations by defining a
+  # resource_relations class method in your model class that returns a hash like this:
+  #
+  #     {
+  #       :location_id => {:attr_method => "location#name", :attr_type => :string},
+  #       :organizer_id => {:attr_method => "organizer#name", :attr_type => :string}
+  #     }
+  #
+  # With this knowledge Resource#attributes will return location#name and organizer#name instead of location_id
+  # and organizer_id. Refer to Alchemy::ResourcesController for further details on usage.
+  #
+  # == Creation
+  #
+  # Resource needs a controller_path at least. Without other arguments it will guess the model name from it and assume
+  # that the model doesn't live in an engine. Moreover model and controller has to follow Rails' naming convention:
+  #
+  #   Event -> EventsController
+  #
+  # It will also strip "admin" automatically, so this is also valid:
+  #
+  #   Event -> Admin::EventsController
+  #
+  # If your Resource and it's controllers are part of an engine you need to provide Alchemy's module_definition,
+  # so resource can provide the correct url_proxy. If you don't declare it in Alchemy, you need at least provide the
+  # following hash (i.e. if your engine is named EventEngine):
+  #
+  #     resource = Resource.new(controller_path, {"engine_name" => "event_engine"})
+  #
+  # If you don't want to stick with these conventions you can separate model and controller by providing
+  # a model class (for example used by Alchemy's Tags admin interface):
+  #
+  #     resource = Resource.new('/admin/tags', {"engine_name"=>"alchemy"}, ActsAsTaggableOn::Tag)
+  #
   class Resource
-
-    attr_accessor :skip_attributes, :resource_relations
+    attr_accessor :skip_attributes, :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)
+    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.skip_attributes = model.respond_to?(:skip_attributes) ? model.skip_attributes : DEFAULT_SKIPPED_ATTRIBUTES
-      self.resource_relations = model.resource_relations if model.respond_to?(:resource_relations)
+      if model.respond_to?(:resource_relations)
+        if not model.respond_to?(:reflect_on_all_associations)
+          raise MissingActiveRecordAssociation
+        end
+        store_model_associations
+        map_relations
+      end
     end
 
-    def model_array
-      model_array = controller_path_array
-      model_array.delete("admin")
-      model_array
+    def resource_array
+      @_resource_array ||= controller_path_array.reject { |el| el == 'admin' }
     end
 
-    def model
-      @_model ||= model_array.join('/').classify.constantize
+    def resources_name
+      @_resources_name ||= resource_array.last
     end
 
-    def resources_name
-      @_resources_name ||= model_array.last
+    def resource_name
+      @_resource_name ||= resources_name.singularize
     end
 
     def model_name
-      @_model_name ||= resources_name.singularize
+      ActiveSupport::Deprecation.warn("model_name is deprecated. Please use resource_name instead!")
+      resource_name
+    end
+
+    def namespaced_resource_name
+      return @_namespaced_resource_name unless @_namespaced_resource_name.nil?
+      resource_name_array = resource_array
+      resource_name_array.delete(engine_name) if in_engine?
+      @_namespaced_resource_name = resource_name_array.join('_').singularize
+    end
+
+    def namespaced_model_name
+      ActiveSupport::Deprecation.warn("namespaced_model_name is deprecated. Please use namespaced_resource_name instead!")
+      namespaced_resource_name
     end
 
     def permission_scope
@@ -46,21 +124,20 @@ module Alchemy
 
     def attributes
       @_attributes ||= self.model.columns.collect do |col|
-        {:name => (resource_relation_name(col.name) || col.name), :type => (resource_relation_type(col.name) || col.type)} unless self.skip_attributes.include?(col.name)
+        unless self.skip_attributes.include?(col.name)
+          { :name => col.name, :type => resource_relation_type(col.name) || col.type, :relation => resource_relation(col.name) }.delete_if { |k, v | v.nil? }
+        end
       end.compact
     end
 
+    # Returns all columns that are searchable
+    #
+    # For now it only uses string type columns
+    #
     def searchable_attributes
       self.attributes.select { |a| a[:type] == :string }
     end
 
-    def namespaced_model_name
-      return @_namespaced_model_name unless @_namespaced_model_name.nil?
-      model_name_array = self.model_array
-      model_name_array.delete(self.engine_name) if in_engine?
-      @_namespaced_model_name = model_name_array.join('_').singularize
-    end
-
     def in_engine?
       not self.engine_name.nil?
     end
@@ -76,27 +153,28 @@ module Alchemy
     #   de:
     #     alchemy:
     #       resource_help_texts:
-    #         my_resource_model_name:
+    #         my_resource_name:
     #           attribute_name: This is the fancy help text
     #
     def help_text_for(attribute)
-      ::I18n.translate!(attribute[:name], :scope => [:alchemy, :resource_help_texts, model_name])
+      ::I18n.translate!(attribute[:name], :scope => [:alchemy, :resource_help_texts, resource_name])
     rescue ::I18n::MissingTranslationData
       false
     end
 
-  protected
+
+  private
+
+    def guess_model_from_controller_path
+      resource_array.join('/').classify.constantize
+    end
 
     def controller_path_array
       @controller_path.split('/')
     end
 
     def namespace_diff
-      controller_path_array - model_array
-    end
-
-    def resource_relation_name(column_name)
-      resource_relation(column_name).try(:[], :attr_method)
+      controller_path_array - resource_array
     end
 
     def resource_relation_type(column_name)
@@ -107,5 +185,30 @@ module Alchemy
       resource_relations[column_name.to_sym] if resource_relations
     end
 
+    # Expands the resource_relations hash with matching activerecord associations data.
+    def map_relations
+      self.resource_relations = {}
+      model.resource_relations.each do |name, options|
+        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
+        if options[:attr_method].to_s =~ /#/
+          ActiveSupport::Deprecation.warn('Old style :attr_method used in Alchemy::Ressource#resource_relations. Please remove the # and pass column name only.', caller[2..10])
+          options[:attr_method] = options[:attr_method].split('#').last
+        end
+        self.resource_relations[foreign_key] = options.merge(:model_association => association, :name => name)
+      end
+    end
+
+    # Stores all activerecord associations in model_associations attribute
+    def store_model_associations
+      self.model_associations = model.reflect_on_all_associations.delete_if { |a| DEFAULT_SKIPPED_ASSOCIATIONS.include?(a.name.to_s) }
+    end
+
+    # Returns activerecord association that has the given name
+    def association_from_relation_name(name)
+      model_associations.detect { |a| a.name == name.to_sym }
+    end
+
   end
 end

data/lib/alchemy/resources_helper.rb

@@ -1,12 +1,18 @@
 module Alchemy
   module ResourcesHelper
+    # = Alchemy::ResourceHelper
+    #
+    # Used to DRY up resource like structures in Alchemy's admin backend in combination with Alchemy::Resource
+    #
+    # See Alchemy::Resource for examples how to initialize a resource_handler
+    #
 
     def resource_window_size
       @resource_window_size ||= "420x#{100 + resource_handler.attributes.length * 40}"
     end
 
     def resource_instance_variable
-      instance_variable_get("@#{resource_handler.model_name}")
+      instance_variable_get("@#{resource_handler.resource_name}")
     end
 
     def resources_instance_variable
@@ -25,20 +31,21 @@ module Alchemy
       @_resource_scope ||= [resource_url_proxy].concat(resource_handler.namespace_for_scope)
     end
 
-    def resources_path(resource=resource_handler.model, options={})
-      polymorphic_path (resource_scope + [resource]), options
+    def resources_path(resource_or_name=resource_handler.resources_name, options={})
+      polymorphic_path (resource_scope + [resource_or_name]), options
     end
 
-    def resource_path(resource=resource_handler.model, options={})
+    def resource_path(resource=resource_handler.resource_name, options={})
       resources_path(resource, options)
     end
 
     def new_resource_path(options={})
-      new_polymorphic_path (resource_scope + [resource_handler.model]), options
+      new_polymorphic_path (resource_scope + [resource_handler.resource_name]), options
     end
 
     def edit_resource_path(resource=nil, options={})
-      edit_polymorphic_path (resource_scope+([resource] or model_array)), options
+      path_segments = (resource_scope + [resource] or resource_handler.resource_array)
+      edit_polymorphic_path path_segments, options
     end
 
     def resource_permission_scope
@@ -46,19 +53,43 @@ module Alchemy
     end
 
     def resource_model_name
-      resource_handler.model_name
+      ActiveSupport::Deprecation.warn("resource_model_name is deprecated. Please use resource_name instead!")
+      resource_handler.resource_name
+    end
+
+    def resource_name
+      resource_handler.resource_name
     end
 
     def resource_model
       resource_handler.model
     end
 
-    def render_attribute(obj, attribute)
-      attr_array = attribute.split('.')
-      attr_array.each do |attr|
-        obj = obj.send(attr) if obj
+    # Returns the value from resource attribute
+    #
+    # If the attribute has a relation, the related object's attribute value will be returned.
+    #
+    # The output will be truncated after 50 chars.
+    #
+    # @param [Alchemy::Resource] resource
+    # @param [Hash] attribute
+    # @option options [Hash] :truncate (50) The length of the value returned.
+    #
+    # @return [String]
+    #
+    def render_attribute(resource, attribute, options={})
+      options.reverse_merge!(truncate: 50)
+      value = resource.send(attribute[:name])
+      if (relation = attribute[:relation]) && value.present?
+        record = relation[:model_association].klass.find(value)
+        value = record.send(relation[:attr_method])
+      elsif attribute[:type] == :datetime && value.present?
+        value = l(value)
       end
-      obj
+      value.to_s.truncate(options[:truncate])
+    rescue ActiveRecord::RecordNotFound => e
+      warning e
+      _t(:not_found)
     end
 
     def resource_help_text(attribute)
@@ -67,5 +98,43 @@ module Alchemy
       end
     end
 
+    # Renders the human model name with a count as h1 header
+    def resources_header
+      content_tag :h1, "#{resources_instance_variable.total_count} #{resource_model.model_name.human(:count => resources_instance_variable.total_count)}"
+    end
+
+    # Returns true if the resource contains any relations
+    def contains_relations?
+      resource_handler.resource_relations.present?
+    end
+
+    # Returns an array of all resource_relations names
+    def resource_relations_names
+      resource_handler.resource_relations.collect { |k, v| v[:name].to_sym }
+    end
+
+    # Returns the attribute's column for sorting
+    #
+    # If the attribute contains a resource_relation, then the table and column for related model will be returned.
+    #
+    def sortable_resource_header_column(attribute)
+      if relation = attribute[:relation]
+        "#{relation[:model_association].table_name}.#{relation[:attr_method]}"
+      else
+        attribute[:name]
+      end
+    end
+
+    # Returns resource relations options hash for a rails select helper.
+    #
+    # @param [Hash] relation
+    # @returns Hash
+    #
+    def options_for_resource_relation_select(relation)
+      relation[:model_association].klass.all.collect do |r|
+        [r.send(relation[:attr_method]), r.id]
+      end
+    end
+
   end
 end

data/lib/alchemy/upgrader.rb

@@ -1,191 +1,29 @@
-require 'fileutils'
-require 'active_record'
-
 module Alchemy
   class Upgrader < Alchemy::Seeder
-
     class << self
 
-      # Runs all ugrades
+      # Runs ugrades
+      #
+      # Set UPGRADE env variable to only run a specific task.
       def run!
-        Rake::Task['alchemy:install:migrations'].invoke
-        strip_alchemy_from_schema_version_table
-        Rake::Task['db:migrate'].invoke
-        Seeder.seed!
-        upgrade_to_language
-        upgrade_layoutpages
-        upgrade_essence_link_target_default
-        upgrade_to_namespaced_essence_type
-        convert_essence_texts_displayed_as_select_into_essence_selects
-        convert_essence_texts_displayed_as_checkbox_into_essence_booleans
-        copy_new_config_file
-        gallery_pictures_change_notice
-        removed_richmedia_essences_notice
-        convert_picture_storage
-        removed_standard_set_notice
-        renamed_t_method
-        migrated_to_devise
-
-        display_todos
-      end
-
-    private
-
-      # Creates Language model if it does not exist (Alchemy CMS prior v1.5)
-      # Also creates missing associations between pages and languages
-      def upgrade_to_language
-        desc "Creating languages for pages"
-        Alchemy::Page.all.each do |page|
-          if !page.language_code.blank? && page.language.nil?
-            root = page.get_language_root
-            lang = Alchemy::Language.find_or_create_by_language_code(
-              :name => page.language_code.capitalize,
-              :code => page.language_code,
-              :frontpage_name => root.name,
-              :page_layout => root.page_layout,
-              :public => true
-            )
-            page.language = lang
-            if page.save(:validate => false)
-              log "Set language for page #{page.name} to #{lang.name}."
-            end
-          else
-            log("Language for page #{page.name} already set.", :skip)
-          end
-        end
-      end
-
-      def upgrade_layoutpages
-        desc "Setting language of layoutpages"
-        default_language = Alchemy::Language.get_default
-        layoutpages = Alchemy::Page.layoutpages
-        if layoutpages.any?
-          layoutpages.each do |page|
-            if page.language.class == String || page.language.nil?
-              page.language = default_language
-              if page.save(:validate => false)
-                log "Set language for page #{page.name} to #{default_language.name}."
-              end
-            else
-              log "Language for page #{page.name} already set.", :skip
-            end
+        if ENV['UPGRADE']
+          ENV['UPGRADE'].split(',').each do |task|
+            self.send(task)
           end
         else
-          log "No layoutpages found.", :skip
+          run_all
         end
+        display_todos
       end
 
-      def upgrade_essence_link_target_default
-        desc "Setting new link_target default"
-        essences = (Alchemy::EssencePicture.all + Alchemy::EssenceText.all)
-        if essences.any?
-          essences.each do |essence|
-            case essence.link_target
-            when '1'
-              if essence.update_column(:link_target, 'blank')
-                log("Updated #{essence.preview_text} link target to #{essence.link_target}.")
-              end
-            when '0'
-              essence.update_column(:link_target, nil)
-              log("Updated #{essence.preview_text} link target to #{essence.link_target.inspect}.")
-            else
-              log("#{essence.preview_text} already upgraded.", :skip)
-            end
-          end
-        else
-          log("No essences to upgrade found.", :skip)
-        end
-      end
-
-      # Updates all essence_type of Content if not already namespaced.
-      def upgrade_to_namespaced_essence_type
-        desc "Namespacing essence_type columns"
-        depricated_contents = Alchemy::Content.where("essence_type LIKE ?", "Essence%")
-        if depricated_contents.any?
-          success = 0
-          errors = []
-          depricated_contents.each do |c|
-            if c.update_column(:essence_type, c.essence_type.gsub(/^Essence/, 'Alchemy::Essence'))
-              success += 1
-            else
-              errors << c.errors.full_messages
-            end
-          end
-          log("Namespaced #{success} essence_type columns.") if success > 0
-          log("#{errors.count} errors while namespacing essence_type columns.\n#{errors.join('\n')}", :error) if errors.count > 0
-        else
-          log "No essence_type columns to be namespaced found.", :skip
-        end
-      end
-
-      def strip_alchemy_from_schema_version_table
-        desc "Strip -alchemy suffix from schema_version table."
-        database_yml = YAML.load_file(Rails.root.join("config", "database.yml"))
-        adapter = ActiveRecord::Base.establish_connection(database_yml.fetch(Rails.env.to_s).symbolize_keys)
-        adapter.connection.update("UPDATE schema_migrations SET version = REPLACE(`schema_migrations`.`version`,'-alchemy','')")
-      end
-
-      def convert_essence_texts_displayed_as_select_into_essence_selects
-        desc "Converting EssenceTexts displayed as select into EssenceSelects"
-        contents_found = 0
-        elements = Alchemy::Element.descriptions.select { |e| e['contents'].present? && !e['contents'].detect { |c| c['settings'].present? && c['settings']['display_as'] == 'select' }.nil? }
-        contents = elements.collect { |el| el['contents'] }.flatten.select { |c| c['settings'] && c['settings']['display_as'] == 'select' }.flatten
-        content_names = contents.collect { |c| c['name'] }
-        Alchemy::Content.essence_texts.where(
-          :name => content_names,
-          :alchemy_elements => {:name => elements.collect { |e| e['name'] }}
-        ).joins(:element).each do |content|
-          new_content = Alchemy::Content.new(:name => content.name, :element_id => content.element.id)
-          if new_content.create_essence!('name' => content.name, 'type' => 'EssenceSelect')
-            new_content.essence.value = content.ingredient
-            if new_content.essence.save
-              contents_found += 1
-              log "Converted #{content.name}'s essence_type into EssenceSelect"
-              content.destroy
-            else
-              log "Could not save essence: #{new_content.essence.errors.full_messages.join(', ')}", :error
-            end
-          else
-            log "Could not create content: #{new_content.errors.full_messages.join(', ')}", :error
-          end
-        end
-        if contents_found > 0
-          todo "Please open your elements.yml file and change all type values from these contents:\n\n#{content_names.join(', ')}\n\ninto EssenceSelect."
-        else
-          log "No EssenceTexts with display_as select setting found.", :skip
-        end
+      def run_all
+        Rake::Task['alchemy:install:migrations'].invoke
+        Rake::Task['db:migrate'].invoke
+        Seeder.seed!
+        copy_new_config_file
       end
 
-      def convert_essence_texts_displayed_as_checkbox_into_essence_booleans
-        desc "Converting EssenceTexts displayed as checkbox into EssenceBooleans"
-        contents_found = 0
-        elements = Alchemy::Element.descriptions.select { |e| e['contents'].present? && !e['contents'].detect { |c| c['settings'].present? && c['settings']['display_as'] == 'checkbox' }.nil? }
-        contents = elements.collect { |el| el['contents'] }.flatten.select { |c| c['settings'] && c['settings']['display_as'] == 'checkbox' }.flatten
-        content_names = contents.collect { |c| c['name'] }
-        Alchemy::Content.essence_texts.where(
-          :name => content_names,
-          :alchemy_elements => {:name => elements.collect { |e| e['name'] }}
-        ).joins(:element).each do |content|
-          new_content = Alchemy::Content.new(:name => content.name, :element_id => content.element.id)
-          if new_content.create_essence!('name' => content.name, 'type' => 'EssenceBoolean')
-            new_content.essence.value = content.ingredient
-            if new_content.essence.save
-              contents_found += 1
-              log "Converted #{content.name}'s essence_type into EssenceBoolean"
-              content.destroy
-            else
-              log "Could not save essence: #{new_content.essence.errors.full_messages.join(', ')}", :error
-            end
-          else
-            log "Could not create content: #{new_content.errors.full_messages.join(', ')}", :error
-          end
-        end
-        if contents_found > 0
-          todo "Please open your elements.yml file and change all type values from these contents:\n\n#{content_names.join(', ')}\n\ninto EssenceBoolean."
-        else
-          log "No EssenceTexts with display_as checkbox setting found.", :skip
-        end
-      end
+    private
 
       def copy_new_config_file
         desc "Copy configuration file."
@@ -201,106 +39,6 @@ module Alchemy
         end
       end
 
-      def gallery_pictures_change_notice
-        txt = ["We have changed the way Alchemy handles EssencePictures in elements."]
-        txt << "It is now possible to have single EssencePictures and galleries side by side in the same element."
-        txt << "All element editor views containing render_picture_editor with option `maximum_amount_of_images => 1` must be changed into render_essence_editor_by_name."
-        txt << "In the yml description of these elements add a new content for this picture."
-        txt << "\nIn order to upgrade your elements in the database run:"
-        txt << "\nrails g alchemy:gallery_pictures_migration\n"
-        txt << "and alter `db/seeds.rb`, so that it contains all elements that have essence pictures."
-        todo txt.join("\n")
-      end
-
-      def removed_richmedia_essences_notice
-        warn = <<-WARN
-We removed the EssenceAudio, EssenceFlash and EssenceVideo essences from Alchemy core!
-In order to get the essences back, install the `alchemy-richmedia-essences` gem.
-
-gem 'alchemy-richmedia-essences'
-
-We left the tables in your database, you can simply drop them if you don't use these essences in your project.
-
-drop_table :alchemy_essence_audios
-drop_table :alchemy_essence_flashes
-drop_table :alchemy_essence_videos
-WARN
-        todo warn
-      end
-
-      def convert_picture_storage
-        desc "Convert the picture storage"
-        converted_images = []
-        images = Dir.glob Rails.root.join 'uploads/pictures/**/*.*'
-        if images.blank?
-          log "No pictures found", :skip
-        else
-          images.each do |image|
-            image_uid = image.gsub(/#{Rails.root.to_s}\/uploads\/pictures\//, '')
-            image_id = image_uid.split('/').last.split('.').first
-            picture = Alchemy::Picture.find_by_id(image_id)
-            if picture && picture.image_file_uid.blank?
-              picture.image_file_uid = image_uid
-              picture.image_file_size = File.new(image).size
-              if picture.save!
-                log "Converted #{image_uid}"
-              end
-            else
-              log "Picture with id #{image_id} not found or already converted.", :skip
-            end
-          end
-        end
-      end
-
-      def removed_standard_set_notice
-        warn = <<-WARN
-We removed the standard set from Alchemy core!
-In order to get the standard set back, install the `alchemy-demo_kit` gem.
-WARN
-        todo warn
-      end
-
-      def renamed_t_method
-        warn = <<-WARN
-We renamed alchemy's `t` method override into `_t` to avoid conflicts with Rails own t method!
-If you use the `t` method to translate alchemy scoped keys, then you have to use the `_t` method from now on.
-WARN
-        todo warn
-      end
-
-      def migrated_to_devise
-        warn = <<-WARN
-We changed the authentication provider from Authlogic to Devise.
-
-If you are upgrading from an old Alchemy version < 2.5.0, then you have to make changes to your Devise configuration.
-
-  1. Run:
-
-  $ rails g alchemy:devise
-
-  And alter the encryptor to authlogic_sha512
-  and the stretches value from 10 to 20
-
-  # config/initializers/devise.rb
-  config.stretches = Rails.env.test? ? 1 : 20
-  config.encryptor = :authlogic_sha512
-
-  2. Add the encryptable module to your Alchemy config.yml:
-
-  # config/alchemy/config.yml
-  devise_modules:
-    - :database_authenticatable
-    - :trackable
-    - :validatable
-    - :timeoutable
-    - :recoverable
-    - :encryptable
-
-WARN
-        todo warn
-      end
-
     end
-
   end
 end