alchemy_cms 2.1.beta6 → 2.1.rc2

data/lib/alchemy/mount_point.rb

@@ -0,0 +1,10 @@
+module Alchemy
+
+	# Returns alchemys mount point in current rails app.
+	def self.mount_point
+		alchemy_routes = Rails.application.routes.named_routes[:alchemy]
+		raise "Alchemy not mounted! Please mount Alchemy::Engine in your config/routes.rb file." if alchemy_routes.nil?
+		alchemy_routes.path.gsub(/^\/$/, '')
+	end
+
+end

data/lib/alchemy/page_layout.rb

@@ -17,7 +17,7 @@ module Alchemy
 
 		# Returns the page_layout.yml file. Tries to first load from config/alchemy and if not found from vendor/plugins/alchemy/config/alchemy.
 		def self.get_layouts
-			@@definitions = read_layouts_file
+			@@definitions ||= read_layouts_file
 		end
 
 		# Add additional pagelayout definitions. I.E. from your module.
@@ -25,7 +25,7 @@ module Alchemy
 		# You can pass a single layout definition as Hash, or a collection of pagelayouts as Array.
 		# Example Pagelayout definitions can be found in the +page_layouts.yml+ from the standard set.
 		def self.add(page_layout)
-			@@definitions = read_layouts_file
+			@@definitions ||= read_layouts_file
 			if page_layout.is_a?(Array)
 				@@definitions += page_layout
 			elsif page_layout.is_a?(Hash)
@@ -45,10 +45,10 @@ module Alchemy
 		def self.get_all_by_attributes(attributes)
 			return [] if attributes.blank?
 			if attributes.class.name == 'Hash'
-				all_definitions = read_layouts_file
+				@@definitions ||= read_layouts_file
 				layouts = []
-				attributes.each do |key, value|
-					result = all_definitions.select{ |a| a[key.to_s].to_s.downcase == value.to_s.downcase if a.has_key?(key.to_s) }
+				attributes.stringify_keys.each do |key, value|
+					result = @@definitions.select{ |a| a[key].to_s.downcase == value.to_s.downcase if a.has_key?(key) }
 					layouts += result unless result.empty?
 				end
 				return layouts
@@ -71,9 +71,9 @@ module Alchemy
 			@@definitions.select do |layout|
 				used = layout["unique"] && has_a_page_this_layout?(layout["name"], language_id)
 				if layoutpage
-					layout["layoutpage"] == true && !used && layout["newsletter"] != true
+					layout["layoutpage"] == true && !used
 				else
-					layout["layoutpage"] != true && !used && layout["newsletter"] != true
+					layout["layoutpage"] != true && !used
 				end
 			end
 		end

data/lib/alchemy/seeder.rb

@@ -1,61 +1,99 @@
-require 'yaml'
+require 'thor/shell/color'
 
 module Alchemy
 	class Seeder
 
-		# This seed builds the necessary page structure for alchemy in your db.
-		# Put Alchemy::Seeder.seed! inside your db/seeds.rb file and run it with rake db:seed.
-		def self.seed!
-			errors = []
-			notices = []
-			
-			default_language = Alchemy::Config.get(:default_language)
-			
-			lang = Language.find_or_initialize_by_code(
-				:name => default_language['name'],
-				:code => default_language['code'],
-				:frontpage_name => default_language['frontpage_name'],
-				:page_layout => default_language['page_layout'],
-				:public => true,
-				:default => true
-			)
-			if lang.new_record?
-				if lang.save
-					puts "== Created language #{lang.name}"
+		class << self
+
+			# This seed builds the necessary page structure for alchemy in your database.
+			# Run the alchemy:db:seed rake task to seed your database.
+			def seed!
+				desc "Seeding your database"
+				errors = []
+				notices = []
+				
+				default_language = Alchemy::Config.get(:default_language)
+				
+				lang = Alchemy::Language.find_or_initialize_by_code(
+					:name => default_language['name'],
+					:code => default_language['code'],
+					:frontpage_name => default_language['frontpage_name'],
+					:page_layout => default_language['page_layout'],
+					:public => true,
+					:default => true
+				)
+				if lang.new_record?
+					if lang.save
+						log "Created language #{lang.name}."
+					else
+						errors << "Errors while creating language #{lang.name}: #{lang.errors.full_messages}"
+					end
+				else
+					notices << "Language #{lang.name} was already present."
+				end
+				
+				root = Alchemy::Page.find_or_initialize_by_name(
+					:name => 'Root',
+					:do_not_sweep => true
+				)
+				if root.new_record?
+					if root.save
+						log "Created page #{root.name}."
+					else
+						errors << "Errors while creating page #{root.name}: #{root.errors.full_messages}"
+					end
 				else
-					errors << "Errors creating language #{lang.name}: #{lang.errors.full_messages}"
+					notices << "Page #{root.name} was already present."
+				end
+				
+				if errors.blank?
+					log "Successfully seeded your database!" if notices.blank?
+					notices.each do |note|
+						log(note, :skip)
+					end
+				else
+					log("Some pages could not be created:", :error)
+					errors.each do |error|
+						log(error, :error)
+					end
 				end
-			else
-				notices << "== Skipping! Language #{lang.name} was already present"
 			end
-			
-			root = Page.find_or_initialize_by_name(
-				:name => 'Root',
-				:page_layout => "rootpage",
-				:do_not_autogenerate => true,
-				:do_not_sweep => true,
-				:language => lang
-			)
-			if root.new_record?
-				if root.save
-					# We have to remove the language, because active record validates its presence on create.
-					root.language = nil
-					root.save
-					puts "== Created page #{root.name}"
+
+		private
+
+			def color(name)
+				case name
+				when :green
+					Thor::Shell::Color::GREEN
+				when :red
+					Thor::Shell::Color::RED
+				when :yellow
+					Thor::Shell::Color::YELLOW
+				when :black
+					Thor::Shell::Color::BLACK
+				when :clear
+					Thor::Shell::Color::CLEAR
 				else
-					errors << "Errors creating page #{root.name}: #{root.errors.full_messages}"
+					""
 				end
-			else
-				notices << "== Skipping! Page #{root.name} was already present"
 			end
-			
-			if errors.blank?
-				puts "Success!"
-				notices.map{ |note| puts note }
-			else
-				puts "WARNING! Some pages could not be created:"
-				errors.map{ |error| puts error }
+
+			def log(message, type=nil)
+				case type
+				when :skip
+					puts "#{color(:yellow)}== Skipping! #{message}#{color(:clear)}"
+				when :error
+					puts "#{color(:red)}!! ERROR: #{message}#{color(:clear)}"
+				else
+					puts "#{color(:green)}== #{message}#{color(:clear)}"
+				end
 			end
+
+			def desc(message)
+				puts "\n#{message}"
+				puts "#{'-' * message.length}\n"
+			end
+
 		end
 
 	end

data/lib/alchemy/upgrader.rb

@@ -0,0 +1,115 @@
+module Alchemy
+	class Upgrader < Alchemy::Seeder
+
+		class << self
+
+			# Runs all ugrades
+			def run!
+				Rake::Task['alchemy:install:migrations'].invoke
+				strip_alchemy_from_schema_version_table
+				Rake::Task['db:migrate'].invoke
+				upgrade_to_language
+				upgrade_layoutpages
+				upgrade_essence_link_target_default
+				upgrade_to_namespaced_essence_type
+			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_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
+					end
+				else
+					log "No layoutpages found.", :skip
+				end
+			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_attribute(:link_target, 'blank')
+								log("Updated #{essence.preview_text} link target to #{essence.link_target}.")
+							end
+						when '0'
+							essence.update_attribute(: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_attribute(: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
+				database_yml = YAML.load_file(Rails.root.join("config", "database.yml"))
+				connection = Mysql2::Client.new(database_yml.fetch(Rails.env.to_s).symbolize_keys)
+				connection.query "UPDATE schema_migrations SET `schema_migrations`.`version` = REPLACE(`schema_migrations`.`version`,'-alchemy','')"
+			end
+
+		end
+
+	end
+end

data/lib/alchemy/version.rb

@@ -1,5 +1,5 @@
 module Alchemy
 
-	VERSION = "2.1.beta6"
+	VERSION = "2.1.rc2"
 
 end

data/lib/alchemy_cms.rb

@@ -14,6 +14,7 @@ if defined?(Rails) && Rails::VERSION::MAJOR == 3
 	require 'extensions/hash'
 	require 'extensions/array'
 	require 'extensions/action_view'
+	require 'alchemy/mount_point'
 	require 'alchemy/version'
 	require 'alchemy/auth_engine'
 	require 'alchemy/engine'
@@ -22,11 +23,11 @@ if defined?(Rails) && Rails::VERSION::MAJOR == 3
 	end
 	require File.join(File.dirname(__FILE__), "alchemy", "seeder")
 else
-	raise "Alchemy 2.0 needs Rails 3.0 or higher. You are currently using Rails #{Rails::VERSION::MAJOR}"
+	raise "Alchemy 2.1 needs Rails 3.1 or higher. You are currently using Rails #{Rails::VERSION::STRING}"
 end
 
 module Alchemy
-  
+
 	class EssenceError < StandardError; end
-  
+
 end

data/lib/rails/generators/alchemy/scaffold/scaffold_generator.rb

@@ -24,11 +24,15 @@ module Alchemy
 			def copy_files
 				if options['with-standard-set']
 					layouts_path = File.expand_path('../../../../../app/views/layouts/alchemy', File.dirname(__FILE__))
+					elements_path = File.expand_path('../../../../../app/views/alchemy/elements', File.dirname(__FILE__))
+					page_layouts_path = File.expand_path('../../../../../app/views/alchemy/page_layouts', File.dirname(__FILE__))
 					copy_file "#{@config_path}/elements.yml", "#{Rails.root}/config/alchemy/elements.yml"
 					copy_file "#{@config_path}/page_layouts.yml", "#{Rails.root}/config/alchemy/page_layouts.yml"
 					copy_file "#{layouts_path}/pages.html.erb", "#{Rails.root}/app/views/layouts/alchemy/pages.html.erb"
-					Rails::Generators.invoke("alchemy:elements")
-					Rails::Generators.invoke("alchemy:page_layouts")
+					Dir.glob("#{elements_path}/*").reject{|file_path| !(File.basename(file_path) =~ /(.+)_(view|editor).html.erb/) }.each do |file_path|
+						copy_file file_path, "#{Rails.root}/app/views/alchemy/elements/#{File.basename(file_path)}"
+					end
+					directory "#{page_layouts_path}/", "#{Rails.root}/app/views/alchemy/page_layouts/"
 				else
 					copy_file "#{File.dirname(__FILE__)}/files/elements.yml", "#{Rails.root}/config/alchemy/elements.yml"
 					copy_file "#{File.dirname(__FILE__)}/files/page_layouts.yml", "#{Rails.root}/config/alchemy/page_layouts.yml"

data/lib/tasks/ferret.rake

@@ -0,0 +1,12 @@
+namespace :ferret do
+  
+  desc "Updates the ferret index for the application."
+  task :rebuild_index => :environment do
+    puts "Rebuilding Ferret Index for EssenceText"
+    Alchemy::EssenceText.rebuild_index
+    puts "Rebuilding Ferret Index for EssenceRichtext"
+    Alchemy::EssenceRichtext.rebuild_index
+    puts "Completed Ferret Index Rebuild"
+  end
+  
+end

data/lib/tasks/install.rake

@@ -1,110 +1,21 @@
-# encoding: UTF-8
-require File.join(File.dirname(__FILE__), '../alchemy/file_utilz.rb')
-
 namespace :alchemy do
-  
-  desc "Migrates the database, inserts essential data into the database and copies all assets."
-  task :prepare do
-    Rake::Task['alchemy:install:migrations'].invoke
-    Rake::Task['alchemy:seeder:copy'].invoke
-    Rake::Task['alchemy:assets:copy:all'].invoke
-  end
-  
-  namespace 'seeder' do
-    desc "Copy a line of code into the seeds.rb file"
-    task :copy do
-      File.open("./db/seeds.rb", "a") do |f|
-        f.puts "\n# Seeding Alchemy data"
-        f.puts "Alchemy::Seeder.seed!\n"
-      end
-    end
-  end
 
-  namespace 'assets' do
-    namespace 'copy' do
-      
-      desc "Copy all assets for Alchemy into apps public folder"
-      task :all do
-        Rake::Task['alchemy:assets:copy:javascripts'].invoke
-        Rake::Task['alchemy:assets:copy:stylesheets'].invoke
-        Rake::Task['alchemy:assets:copy:images'].invoke
-      end
-      
-      desc "Copy javascripts for Alchemy into apps public folder"
-      task :javascripts do
-				system "rm -rf #{Rails.root.to_s}/public/javascripts/alchemy"
-				system "mkdir -p #{Rails.root.to_s}/public/javascripts/alchemy"
-				system "rsync -r #{File.join(File.dirname(__FILE__), '..', '..', 'assets', 'javascripts', '*')} #{Rails.root.to_s}/public/javascripts/alchemy/"
-      end
-      
-      desc "Copy stylesheets for Alchemy into apps public folder"
-      task :stylesheets do
-        system "rm -rf #{Rails.root.to_s}/public/stylesheets/alchemy"
-				system "mkdir -p #{Rails.root.to_s}/public/stylesheets/alchemy"
-				system "rsync -r #{File.join(File.dirname(__FILE__), '..', '..', 'assets', 'stylesheets', '*')} #{Rails.root.to_s}/public/stylesheets/alchemy/"
-      end
-      
-      desc "Copy images for Alchemy into apps public folder"
-      task :images do
-				system "rm -rf #{Rails.root.to_s}/public/images/alchemy"
-				system "mkdir -p #{Rails.root.to_s}/public/images/alchemy"
-				system "rsync -r #{File.join(File.dirname(__FILE__), '..', '..', 'assets', 'images', '*')} #{Rails.root.to_s}/public/images/alchemy/"
-      end
-      
-    end
-  end
-  
-  namespace :standard_set do
-    
-    desc "Install Alchemys standard set."
-    task :install do
-      system("rails g alchemy:scaffold --with_standard_set")
-      Rake::Task['alchemy:assets:copy:all'].invoke
-    end
-    
-  end
+	namespace :db do
 
-  namespace :cells do
-    
-    desc "Creates all cells for all pages"
-    task :create => :environment do
-      cell_yml = File.join(File.dirname(__FILE__), '..', '..', '..', '..', '..', 'config', 'alchemy', 'cells.yml')
-      page_layouts = Alchemy::PageLayout.get_layouts
-      if File.exist?(cell_yml) && page_layouts
-        cells = YAML.load_file(cell_yml)
-        page_layouts.each do |layout|
-          unless layout['cells'].blank?
-            cells_for_layout = cells.select { |cell| layout['cells'].include? cell['name'] }
-            Alchemy::Page.find_all_by_page_layout(layout['name']).each do |page|
-              cells_for_layout.each do |cell_for_layout|
-                cell = Cell.find_or_initialize_by_name_and_page_id({:name => cell_for_layout['name'], :page_id => page.id})
-                cell.elements << page.elements.select { |element| cell_for_layout['elements'].include?(element.name) }
-                if cell.new_record?
-                  cell.save
-                  puts "== Creating cell '#{cell.name}' for page '#{page.name}'"
-                else
-                  puts "== Skipping! Cell '#{cell.name}' for page '#{page.name}' was already present"
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-    
-  end
-  
-end
+		desc "Seeds the database with essential data for Alchemy."
+		task :seed => :environment do
+			Alchemy::Seeder.seed!
+		end
+
+	end
+
+	namespace :standard_set do
+
+		desc "Install Alchemys standard set."
+		task :install do
+			system("rails g alchemy:scaffold --with-standard-set")
+		end
+
+	end
 
-namespace :ferret do
-  
-  desc "Updates the ferret index for the application."
-  task :rebuild_index => :environment do
-    puts "Rebuilding Ferret Index for EssenceText"
-    Alchemy::EssenceText.rebuild_index
-    puts "Rebuilding Ferret Index for EssenceRichtext"
-    Alchemy::EssenceRichtext.rebuild_index
-    puts "Completed Ferret Index Rebuild"
-  end
-  
 end