alchemy_cms 2.9.1 → 3.0.0.rc5

data/db/migrate/20130828121054_remove_do_not_index_from_alchemy_essence_texts.rb

@@ -0,0 +1,5 @@
+class RemoveDoNotIndexFromAlchemyEssenceTexts < ActiveRecord::Migration
+  def up
+    remove_column :alchemy_essence_texts, :do_not_index
+  end
+end

data/db/migrate/20130828121120_remove_do_not_index_from_alchemy_essence_richtexts.rb

@@ -0,0 +1,5 @@
+class RemoveDoNotIndexFromAlchemyEssenceRichtexts < ActiveRecord::Migration
+  def up
+    remove_column :alchemy_essence_richtexts, :do_not_index
+  end
+end

data/db/migrate/20130918201742_add_published_at_to_alchemy_pages.rb

@@ -0,0 +1,5 @@
+class AddPublishedAtToAlchemyPages < ActiveRecord::Migration
+  def change
+    add_column :alchemy_pages, :published_at, :timestamp
+  end
+end

data/db/migrate/20140107192720_add_missing_unique_indices_to_tags_and_taggings.rb

@@ -0,0 +1,21 @@
+class AddMissingUniqueIndicesToTagsAndTaggings < ActiveRecord::Migration
+
+  def self.up
+    add_index :tags, :name, unique: true
+
+    remove_index :taggings, :tag_id
+    remove_index :taggings, [:taggable_id, :taggable_type, :context]
+    add_index :taggings,
+      [:tag_id, :taggable_id, :taggable_type, :context, :tagger_id, :tagger_type],
+      unique: true, name: 'taggings_idx'
+  end
+
+  def self.down
+    remove_index :tags, :name
+
+    remove_index :taggings, name: 'tagging_idx'
+    add_index :taggings, :tag_id
+    add_index :taggings, [:taggable_id, :taggable_type, :context]
+  end
+
+end

data/lib/alchemy/auth_accessors.rb

@@ -4,7 +4,7 @@
 #
 # +Alchemy.user_class_name+ defaults to +'User'+
 # +Alchemy.login_path defaults to +'/login'+
-# +Alchemy.logout_path defaults to +'/admin/logout'+
+# +Alchemy.logout_path defaults to +'/logout'+
 #
 # Anyway, you can tell Alchemy about your authentication model configuration:
 #
@@ -22,12 +22,19 @@
 # If you don't have your own user model or don't want to provide one,
 # add the `alchemy-devise` gem into your App's Gemfile.
 #
+# == Adding your own CanCan abilities
+#
+# If your app or your engine has own CanCan abilities you must register them:
+#
+#     Alchemy.register_ability MyCustom::Ability
+#
 module Alchemy
-  mattr_accessor :user_class_name, :login_path, :logout_path
+  mattr_accessor :user_class_name, :current_user_method, :login_path, :logout_path
 
   # Defaults
   #
   @@user_class_name = 'User'
+  @@current_user_method = 'current_user'
   @@login_path = '/login'
   @@logout_path = '/logout'
 
@@ -51,4 +58,18 @@ module Alchemy
       end
     end
   end
+
+  # Register a CanCan Ability class
+  #
+  def self.register_ability(klass)
+    @abilities ||= []
+    @abilities << klass
+  end
+
+  # All CanCan Ability classes registered to Alchemy
+  #
+  def self.registered_abilities
+    @abilities ||= []
+  end
+
 end

data/lib/alchemy/cache_digests/template_tracker.rb

@@ -0,0 +1,65 @@
+module Alchemy
+  module CacheDigests
+    class TemplateTracker
+
+      def self.call(name, template)
+        new(name, template).dependencies
+      end
+
+      def initialize(name, template)
+        @name, @template = name, template
+      end
+
+      def dependencies
+        case @name.to_s
+        when /^alchemy\/pages\/show/
+          return PageLayout.all.collect { |p| "alchemy/page_layouts/_#{p['name']}" }
+        when /^alchemy\/page_layouts\/_(.+)/
+          page_layout = page_layout($1)
+          return element_templates(page_layout) +
+            page_layout.fetch('cells', []).map { |name| "alchemy/cells/_#{name}" }
+        when /^alchemy\/cells\/_(.+)/
+          return element_templates cell_definition($1)
+        when /alchemy\/elements\/_(.+)_view/
+          essences = essence_types($1)
+          element = element_description($1)
+          if element && element['picture_gallery']
+            essences += ['EssencePicture']
+          end
+          return essences.map { |name| "alchemy/essences/_#{name.underscore}_view" }.uniq
+        else
+          ActionView::DependencyTracker::ERBTracker.call(@name, @template)
+        end
+      end
+
+      private
+
+      def element_templates(collection)
+        collection.fetch('elements', []).map { |name| "alchemy/elements/_#{name}_view" }
+      end
+
+      def page_layout(name)
+        PageLayout.get(name)
+      end
+
+      def cell_definition(name)
+        Cell.definition_for(name)
+      end
+
+      def element_description(name)
+        Element.descriptions.detect { |e| e['name'] == name }
+      end
+
+      def essence_types(name)
+        element = element_description(name)
+        if element
+          (element.fetch('contents', []) +
+            element.fetch('available_contents', [])).collect { |c| c['type'] }
+        else
+          []
+        end
+      end
+
+    end
+  end
+end

data/lib/alchemy/capistrano.rb

@@ -1,7 +1,10 @@
-# This recipe contains Capistrano recipes for handling the uploads, ferret index and picture cache files while deploying your application.
-# It also contains a ferret:rebuild_index task to rebuild the index after deploying your application.
+# This recipe contains Capistrano recipes for handling the uploads and picture cache files while deploying your application.
+#
 require 'fileutils'
 require 'alchemy/tasks/helpers'
+# Loading the current Rails app's env, so we can get the Alchemy mount point.
+require './config/environment.rb'
+require 'alchemy/mount_point'
 
 include Alchemy::Tasks::Helpers
 
@@ -15,25 +18,36 @@ include Alchemy::Tasks::Helpers
 
     namespace :shared_folders do
 
-      # This task creates the shared folders for uploads, picture cache and ferret index while setting up your server.
-      # Call after deploy:setup like +after "deploy:setup", "alchemy:create_shared_folders"+ in your +deploy.rb+.
-      desc "Creates the uploads and picture cache directory in the shared folder. Call after deploy:setup"
+      # This task creates the shared folders for uploads, assets and picture cache while setting up your server.
+      desc "Creates the uploads and picture cache directory in the shared folder. Called after deploy:setup"
       task :create, :roles => :app do
-        run "mkdir -p #{shared_path}/index"
         run "mkdir -p #{shared_path}/uploads/pictures"
         run "mkdir -p #{shared_path}/uploads/attachments"
-        run "mkdir -p #{File.join(shared_path, 'cache', Capistrano::CLI.ui.ask("\nWhere is Alchemy CMS mounted at? ('/'): "), 'pictures')}"
+        run "mkdir -p #{shared_picture_cache_path}"
+        run "mkdir -p #{shared_path}/cache/assets"
       end
 
-      # This task sets the symlinks for uploads, picture cache and ferret index folder.
-      # Call after deploy:symlink like +after "deploy:symlink", "alchemy:symlink_folders"+ in your +deploy.rb+.
-      desc "Sets the symlinks for uploads, picture cache and ferret index folder. Call after deploy:symlink"
+      # This task sets the symlinks for uploads, assets and picture cache folder.
+      desc "Sets the symlinks for uploads and picture cache folder. Called after deploy:finalize_update"
       task :symlink, :roles => :app do
         run "rm -rf #{release_path}/uploads"
         run "ln -nfs #{shared_path}/uploads #{release_path}/"
-        run "ln -nfs #{shared_path}/cache/* #{release_path}/public/"
-        run "rm -rf #{release_path}/index"
-        run "ln -nfs #{shared_path}/index #{release_path}/"
+        run "mkdir -p #{public_path_with_mountpoint}"
+        run "ln -nfs #{shared_picture_cache_path} #{public_path_with_mountpoint('pictures')}"
+        run "mkdir -p #{release_path}/tmp/cache"
+        run "ln -nfs #{shared_path}/cache/assets #{release_path}/tmp/cache/assets"
+      end
+
+      def shared_picture_cache_path
+        @shared_picture_cache_path ||= begin
+          File.join(shared_path, 'cache', Alchemy::MountPoint.get, 'pictures')
+        end
+      end
+
+      def public_path_with_mountpoint(suffix = '')
+        @release_picture_cache_path ||= begin
+          File.join(release_path, 'public', Alchemy::MountPoint.get, suffix)
+        end
       end
 
     end
@@ -50,7 +64,7 @@ include Alchemy::Tasks::Helpers
         environment      = Capistrano::CLI.ui.ask("\nPlease enter the environment (Default: #{fetch(:rails_env, 'production')})")
         environment      = fetch(:rails_env, 'production') if environment.empty?
         db_adapter       = Capistrano::CLI.ui.ask("Please enter database adapter (Options: mysql2, or postgresql. Default mysql2): ")
-        db_adapter       = db_adapter.empty? ? 'mysql2' : db_adapter.gsub(/^mysql$/, 'mysql2')
+        db_adapter       = db_adapter.empty? ? 'mysql2' : db_adapter.gsub(/\Amysql\z/, 'mysql2')
         db_name          = Capistrano::CLI.ui.ask("Please enter database name: ")
         db_username      = Capistrano::CLI.ui.ask("Please enter database username: ")
         db_password      = Capistrano::CLI.password_prompt("Please enter database password: ")
@@ -135,18 +149,6 @@ EOF
         end
       end
 
-      def database_config
-        raise "database.yml not found!" if !File.exists?("./config/database.yml")
-        @database_config ||= begin
-          config_file = YAML.load_file("./config/database.yml")
-          if config = config_file.fetch(ENV['RAILS_ENV'] || 'development')
-            config
-          else
-            raise "Database configuration for #{ENV['RAILS_ENV'] || 'development'} not found!"
-          end
-        end
-      end
-
       def db_import_cmd(server)
         dump_cmd = "cd #{current_path} && #{rake} RAILS_ENV=#{fetch(:rails_env, 'production')} alchemy:db:dump"
         sql_stream = "ssh -p #{fetch(:port, 22)} #{user}@#{server} '#{dump_cmd}'"
@@ -156,16 +158,4 @@ EOF
 
   end
 
-  namespace :ferret do
-
-    # This task rebuilds the ferret index for the EssenceText and EssenceRichtext Models.
-    # Call it before deploy:restart like +before "deploy:restart", "alchemy:rebuild_index"+ in your +deploy.rb+.
-    # It uses the +alchemy:rebuild_index+ rake task found in +vendor/plugins/alchemy/lib/tasks+.
-    desc "Rebuild the ferret index. Call before deploy:restart"
-    task :rebuild_index, :roles => :app do
-      run "cd #{current_path} && #{rake} RAILS_ENV=#{fetch(:rails_env, 'production')} ferret:rebuild_index"
-    end
-
-  end
-
 end

data/lib/alchemy/controller_actions.rb

@@ -0,0 +1,130 @@
+module Alchemy
+  module ControllerActions
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :set_current_alchemy_site
+      before_action :set_alchemy_language
+
+      helper 'alchemy/pages'
+
+      helper_method :current_alchemy_user,
+        :alchemy_user_signed_in?,
+        :current_alchemy_site,
+        :current_server
+    end
+
+    private
+
+    # Returns a host string with the domain the app is running on.
+    def current_server
+     "#{request.protocol}#{request.host_with_port}"
+    end
+
+    # The current authorized user.
+    #
+    # In order to have Alchemy's authorization work, you have to
+    # provide a +current_user+ method in your app's ApplicationController,
+    # that returns the current user. To change the method +current_alchemy_user+
+    # will call, set +Alchemy.current_user_method+ to a different method name.
+    #
+    # If you don't have an App that can provide a +current_user+ object,
+    # you can install the `alchemy-devise` gem that provides everything you need.
+    #
+    def current_alchemy_user
+      current_user_method = Alchemy.current_user_method
+      raise NoCurrentUserFoundError if !respond_to?(current_user_method, true)
+      send current_user_method
+    end
+
+    # Returns true if a +current_alchemy_user+ is present
+    #
+    def alchemy_user_signed_in?
+      current_alchemy_user.present?
+    end
+
+    # Returns the current site.
+    #
+    def current_alchemy_site
+      @current_alchemy_site ||= Site.find_for_host(request.host)
+    end
+
+    # Ensures usage of Alchemy's permissions class.
+    #
+    # Merges existing CanCan abilities from host Rails app with Alchemy's own CanCan abilities.
+    #
+    # == Register Abilities
+    #
+    # If your app's CanCan ability class is not named +Ability+ you have to register it.
+    # Or if you have a engine with own CanCan abilities you want to add to Alchemy you must register them first.
+    #
+    #     Alchemy.register_ability MyCustom::Permisson
+    #
+    def current_ability
+      @current_ability ||= begin
+        alchemy_permissions = Alchemy::Permissions.new(current_alchemy_user)
+        Alchemy.registered_abilities.each do |klass|
+          alchemy_permissions.merge(klass.new(current_alchemy_user))
+        end
+        if (Object.const_get('Ability') rescue false)
+          alchemy_permissions.merge(Ability.new(current_alchemy_user))
+        end
+        alchemy_permissions
+      end
+    end
+
+    # Sets the current site in a cvar so the Language model
+    # can be scoped against it.
+    #
+    def set_current_alchemy_site
+      Site.current = current_alchemy_site
+    end
+
+    # Try to find and stores current language for Alchemy.
+    #
+    def set_alchemy_language(lang = nil)
+      if lang
+        @language = lang.is_a?(Language) ? lang : load_alchemy_language_from_id_or_code(lang)
+      else
+        # find the best language and remember it for later
+        @language = load_alchemy_language_from_params ||
+                    load_alchemy_language_from_session ||
+                    load_default_alchemy_language
+      end
+      store_current_alchemy_language(@language)
+    end
+
+    def load_alchemy_language_from_params
+      if params[:lang].present?
+        Language.find_by_code(params[:lang])
+      end
+    end
+
+    def load_alchemy_language_from_session
+      if session[:alchemy_language_id].present?
+        Language.find_by(id: session[:alchemy_language_id])
+      end
+    end
+
+    def load_alchemy_language_from_id_or_code(id_or_code)
+      Language.find_by(id: id_or_code) ||
+      Language.find_by_code(id_or_code)
+    end
+
+    def load_default_alchemy_language
+      Language.default || raise(DefaultLanguageNotFoundError)
+    end
+
+    # Stores language's id in the session.
+    #
+    # Also stores language in +Language.current+
+    #
+    def store_current_alchemy_language(language)
+      if language && language.id
+        session[:alchemy_language_id] = language.id
+        Language.current = language
+      end
+    end
+
+  end
+end

data/lib/alchemy/engine.rb

@@ -1,41 +1,51 @@
 # Require globally used external libraries
+require 'actionpack/page_caching'
+require 'acts_as_list'
+require 'acts-as-taggable-on'
+require 'action_view/dependency_tracker'
+require 'active_model_serializers'
+require 'awesome_nested_set'
+require 'cancan'
 require 'coffee-rails'
 require 'compass-rails'
-require 'declarative_authorization'
-require 'dynamic_form'
+require 'dragonfly'
 require 'jquery-rails'
 require 'jquery-ui-rails'
 require 'kaminari'
-require 'rails3-jquery-autocomplete'
+require 'non-stupid-digest-assets'
 require 'sass-rails'
 require 'sassy-buttons'
+require 'simple_form'
+require 'select2-rails'
+require 'turbolinks'
 require 'userstamp'
 
 # Require globally used Alchemy mixins
-require 'alchemy/auth/engine'
-require 'alchemy/auth_accessors'
-require 'alchemy/config'
-require 'alchemy/errors'
-require 'alchemy/essence'
-require 'alchemy/ferret/search'
-require 'alchemy/filetypes'
-require 'alchemy/i18n'
-require 'alchemy/language_helpers'
-require 'alchemy/logger'
-require 'alchemy/modules'
-require 'alchemy/mount_point'
-require 'alchemy/name_conversions'
-require 'alchemy/page_layout'
-require 'alchemy/picture_attributes'
-require 'alchemy/resource'
-require 'alchemy/tinymce'
+require_relative './auth_accessors'
+require_relative './cache_digests/template_tracker'
+require_relative './config'
+require_relative './controller_actions'
+require_relative './errors'
+require_relative './essence'
+require_relative './filetypes'
+require_relative './forms/builder'
+require_relative './hints'
+require_relative './i18n'
+require_relative './locale'
+require_relative './logger'
+require_relative './modules'
+require_relative './mount_point'
+require_relative './name_conversions'
+require_relative './page_layout'
+require_relative './permissions'
+require_relative './picture_attributes'
+require_relative './resource'
+require_relative './tinymce'
+require_relative './touching'
 
 # Require hacks
-require 'alchemy/kaminari/scoped_pagination_url_helper'
-require File.join(File.dirname(__FILE__), '../extensions/action_view')
-
-# Require middleware
-require File.join(File.dirname(__FILE__), '../middleware/flash_session_cookie')
+require_relative './kaminari/scoped_pagination_url_helper'
+require_relative '../extensions/action_view'
 
 module Alchemy
   class Engine < Rails::Engine
@@ -46,37 +56,34 @@ module Alchemy
     # Enabling assets precompiling
     initializer 'alchemy.assets' do |app|
       app.config.assets.precompile += [
-        "alchemy/alchemy.js",
-        "alchemy/preview.js",
-        "alchemy/admin.css",
-        "alchemy/menubar.css",
-        "alchemy/menubar.js",
-        "alchemy/print.css",
-        "alchemy/tinymce_content.css",
-        "alchemy/tinymce_dialog.css",
-        "tiny_mce/*"
+        'alchemy/alchemy.js',
+        'alchemy/preview.js',
+        'alchemy/admin.css',
+        'alchemy/menubar.css',
+        'alchemy/menubar.js',
+        'alchemy/print.css',
+        'tinymce/*'
       ]
     end
 
-    initializer 'alchemy.flash_cookie' do |config|
-      config.middleware.insert_after(
-        'ActionDispatch::Cookies',
-        Alchemy::Middleware::FlashSessionCookie,
-        ::Rails.configuration.session_options[:key]
-      )
-    end
-
-    initializer "alchemy.add_authorization_rules" do
-      Alchemy::Auth::Engine.get_instance.load(File.join(File.dirname(__FILE__), '../..', 'config/authorization_rules.rb'))
+    initializer 'alchemy.dependency_tracker' do |app|
+      [:erb, :slim, :haml].each do |handler|
+        ActionView::DependencyTracker.register_tracker(handler, CacheDigests::TemplateTracker)
+      end
     end
 
-    config.to_prepare do
-      ApplicationController.send(:include, Alchemy::LanguageHelpers)
+    initializer 'alchemy.non_digest_assets' do |app|
+      NonStupidDigestAssets.whitelist = [/^tinymce\//]
     end
 
     config.after_initialize do
-      require 'alchemy/userstamp'
+      require_relative './userstamp'
     end
 
+    config.to_prepare do
+      # In order to have Alchemy's helpers and basic controller methods
+      # available in the host app, we patch the ApplicationController.
+      ApplicationController.send(:include, Alchemy::ControllerActions)
+    end
   end
 end