alchemy_cms 2.5.3.1 → 2.6.0.rc5

data/lib/alchemy/version.rb

@@ -1,6 +1,6 @@
 module Alchemy
 
-  VERSION = "2.5.3.1"
+  VERSION = "2.6.0.rc5"
 
   def self.version
     VERSION

data/lib/alchemy_cms.rb

@@ -3,7 +3,6 @@ require 'rails'
 if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR == 2
   require 'acts_as_list'
   require 'acts-as-taggable-on'
-  require 'attachment_magic'
   require 'devise'
   require 'devise-encryptable'
   require 'awesome_nested_set'
@@ -12,6 +11,7 @@ if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR == 2
   require 'jquery-rails'
   require 'jquery-ui-rails'
   require 'rails3-jquery-autocomplete'
+  require 'handles_sortable_columns'
   require 'kaminari'
   require 'userstamp'
   require 'yaml'
@@ -28,7 +28,22 @@ if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR == 2
   require 'alchemy/auth_engine'
   require 'alchemy/engine'
   require 'alchemy/picture_attributes'
-  %w(config logger errors essence page_layout modules tinymce i18n scoped_pagination_url_helper resource resources_helper ferret_search).each do |class_name|
+  [
+    'config',
+    'logger',
+    'errors',
+    'essence',
+    'page_layout',
+    'modules',
+    'tinymce',
+    'i18n',
+    'scoped_pagination_url_helper',
+    'resource',
+    'resources_helper',
+    'ferret_search',
+    'filetypes',
+    'name_conversions'
+  ].each do |class_name|
     require File.join(File.dirname(__FILE__), "alchemy", class_name)
   end
   require File.join(File.dirname(__FILE__), "alchemy", "seeder")

data/lib/rails/generators/alchemy/deploy_script/templates/deploy.rb.tt

@@ -94,7 +94,7 @@ namespace :deploy do
 
   desc 'Seeds the database'
   task :seed, :roles => :app, :except => { :no_release => true } do
-    run "cd #{release_path} && RAILS_ENV=#{rails_env} #{rake} db:seed"
+    run "cd #{release_path} #{rake} && RAILS_ENV=#{rails_env} db:seed"
   end
 
 end

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

@@ -37,7 +37,7 @@ module Alchemy
       end
 
       def copy_alchemy_views
-        %w(messages navigation notifications search).each do |dir|
+        %w(breadcrumb messages navigation notifications search).each do |dir|
           src = File.expand_path("../../../../../app/views/alchemy/#{dir}", File.dirname(__FILE__))
           dest = Rails.root.join('app/views/alchemy', dir)
           directory src, dest

data/lib/tasks/alchemy/convert.rake

@@ -0,0 +1,39 @@
+namespace :alchemy do
+  namespace :convert do
+
+    namespace :urlnames do
+
+      desc "Converts the urlname of all pages to nested url paths."
+      task :to_nested => [:environment] do
+        unless Alchemy::Config.get(:url_nesting)
+          raise "\nURL nesting is disabled! Please enable url_nesting in `config/alchemy/config.yml` first.\n\n"
+        end
+        puts "Converting..."
+        pages = Alchemy::Page.contentpages
+        count = pages.count
+        pages.each_with_index do |page, n|
+          puts "Updating page #{n+1} of #{count}"
+          page.update_urlname!
+        end
+        puts "Done."
+      end
+
+      desc "Converts the urlname of all pages to contain the slug only."
+      task :to_slug => [:environment] do
+        if Alchemy::Config.get(:url_nesting)
+          raise "\nURL nesting is enabled! Please disable url_nesting in `config/alchemy/config.yml` first.\n\n"
+        end
+        puts "Converting..."
+        pages = Alchemy::Page.contentpages
+        count = pages.count
+        pages.each_with_index do |page, n|
+          puts "Updating page #{n+1} of #{count}"
+          page.update_attribute :urlname, page.slug
+        end
+        puts "Done."
+      end
+
+    end
+
+  end
+end

data/lib/tasks/alchemy/install.rake

@@ -17,14 +17,12 @@ end
 
 namespace :alchemy do
 
+  desc "Creates, migrates and seeds the database to run Alchemy."
+  task :prepare => ["db:create", "alchemy:install:migrations", "db:migrate", "alchemy:db:seed"]
+
   desc "Installs Alchemy CMS into your app."
-  task :install do
-    Rake::Task["db:create"].invoke
-    Rake::Task["alchemy:install:migrations"].invoke
-    Rake::Task["alchemy:mount"].invoke
+  task :install => ["alchemy:prepare", "alchemy:mount"] do
     system("rails g alchemy:scaffold")
-    Rake::Task["db:migrate"].invoke
-    Rake::Task["alchemy:db:seed"].invoke
     puts <<-EOF
 
 \\o/ Successfully installed Alchemy CMS \\o/

data/lib/tasks/alchemy/upgrade.rake

@@ -2,9 +2,26 @@ require File.join(File.dirname(__FILE__), '../../alchemy/upgrader.rb')
 
 namespace :alchemy do
 
-  desc "Upgrades database to Alchemy CMS v#{Alchemy::VERSION}."
+  desc "Upgrades database content to Alchemy CMS v#{Alchemy::VERSION} (Set UPGRADE env variable to only run a specific task)."
   task :upgrade => :environment do
     Alchemy::Upgrader.run!
   end
 
+  namespace :upgrade do
+    desc "List all available upgrade tasks."
+    task :list => [:environment] do
+      puts "\nAvailable upgrade tasks"
+      puts "-----------------------\n"
+      methods = (Alchemy::Upgrader.private_methods - Object.private_methods - Alchemy::Upgrader.superclass.private_methods)
+      if methods.any?
+        methods.each { |method| puts method }
+        puts "\nUsage:"
+        puts "------"
+        puts "Run one or more tasks with `bundle exec rake alchemy:upgrade UPGRADE=task_name1,task_name2`\n"
+      else
+        puts "No upgrades available."
+      end
+    end
+  end
+
 end

data/spec/controllers/admin/clipboard_controller_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 module Alchemy
   describe Admin::ClipboardController do
 
-    let(:page)            { FactoryGirl.create(:public_page) }
-    let(:element)         { FactoryGirl.create(:element, :page => page) }
-    let(:another_element) { FactoryGirl.create(:element, :page => page) }
+    let(:public_page)     { FactoryGirl.create(:public_page) }
+    let(:element)         { FactoryGirl.create(:element, :page => public_page) }
+    let(:another_element) { FactoryGirl.create(:element, :page => public_page) }
 
     before do
       sign_in :user, FactoryGirl.create(:admin_user)
@@ -48,7 +48,7 @@ module Alchemy
 
       context "with pages as remarkable_type" do
         it "should clear the pages clipboard" do
-          session[:clipboard][:pages] = {:id => page.id}
+          session[:clipboard][:pages] = {:id => public_page.id}
           delete(:clear, {:remarkable_type => :pages, :format => :js})
           session[:clipboard].should be_empty
         end

data/spec/controllers/admin/elements_controller_spec.rb

@@ -7,9 +7,9 @@ module Alchemy
       sign_in :user, FactoryGirl.create(:admin_user)
     end
 
-    let(:page) { FactoryGirl.create(:page, :urlname => 'lulu') }
-    let(:element) { FactoryGirl.create(:element, :page_id => page.id) }
-    let(:element_in_clipboard) { FactoryGirl.create(:element, :page_id => page.id) }
+    let(:alchemy_page) { FactoryGirl.create(:page, :urlname => 'lulu') }
+    let(:element) { FactoryGirl.create(:element, :page_id => alchemy_page.id) }
+    let(:element_in_clipboard) { FactoryGirl.create(:element, :page_id => alchemy_page.id) }
     let(:clipboard) { session[:clipboard] = Clipboard.new }
 
     describe '#create' do
@@ -17,9 +17,9 @@ module Alchemy
       before { element }
 
       it "should insert the element at bottom of list" do
-        post :create, {:element => {:name => 'news', :page_id => page.id}, :format => :js}
-        page.elements.count.should == 2
-        page.elements.last.name.should == 'news'
+        post :create, {:element => {:name => 'news', :page_id => alchemy_page.id}, :format => :js}
+        alchemy_page.elements.count.should == 2
+        alchemy_page.elements.last.name.should == 'news'
       end
 
       context "on a page with a setting for insert_elements_at of top" do
@@ -33,9 +33,9 @@ module Alchemy
         end
 
         it "should insert the element at top of list" do
-          post :create, {:element => {:name => 'news', :page_id => page.id}, :format => :js}
-          page.elements.count.should == 2
-          page.elements.first.name.should == 'news'
+          post :create, {:element => {:name => 'news', :page_id => alchemy_page.id}, :format => :js}
+          alchemy_page.elements.count.should == 2
+          alchemy_page.elements.first.name.should == 'news'
         end
       end
     end
@@ -44,7 +44,7 @@ module Alchemy
 
       before do
         Cell.stub!(:definition_for).and_return({'name' => 'header', 'elements' => ['header']})
-        controller.instance_variable_set(:@page, page)
+        controller.instance_variable_set(:@page, alchemy_page)
       end
 
       context "with element name and cell name in the params" do
@@ -59,18 +59,18 @@ module Alchemy
           it "should create the cell" do
             expect {
               controller.send(:find_or_create_cell)
-            }.to change(page.cells, :count).from(0).to(1)
+            }.to change(alchemy_page.cells, :count).from(0).to(1)
           end
         end
 
         context "with the cell already present" do
 
-          before { FactoryGirl.create(:cell, :page => page, :name => 'header') }
+          before { FactoryGirl.create(:cell, :page => alchemy_page, :name => 'header') }
 
           it "should load the cell" do
             expect {
               controller.send(:find_or_create_cell)
-            }.to_not change(page.cells, :count)
+            }.to_not change(alchemy_page.cells, :count)
           end
 
         end
@@ -98,9 +98,9 @@ module Alchemy
       render_views
 
       it "should return a select tag with elements" do
-        Alchemy::Page.should_receive(:find_by_urlname_and_language_id).and_return(page)
+        Alchemy::Page.should_receive(:find_by_urlname_and_language_id).and_return(alchemy_page)
         Alchemy::Element.stub_chain([:published, :find_all_by_page_id]).and_return([element])
-        get :list, {:page_urlname => page.urlname, :format => :js}
+        get :list, {:page_urlname => alchemy_page.urlname, :format => :js}
         response.body.should match(/select(.*)elements_from_page_selector(.*)option/)
       end
 
@@ -145,7 +145,7 @@ module Alchemy
         end
 
         it "should load all elements from clipboard" do
-          get :new, {:page_id => page.id, :format => :js}
+          get :new, {:page_id => alchemy_page.id, :format => :js}
           assigns(:clipboard_items).should be_kind_of(Array)
         end
 
@@ -232,10 +232,10 @@ module Alchemy
           end
 
           context "on a page with a setting for insert_elements_at of top" do
-            let(:page)                 { FactoryGirl.create(:public_page, :name => 'News') }
-            let(:element_in_clipboard) { FactoryGirl.create(:element, :page => page, :name => 'news') }
-            let(:cell)                 { page.cells.first }
-            let(:element)              { FactoryGirl.create(:element, :name => 'news', :page => page, :cell => cell) }
+            let(:alchemy_page)                 { FactoryGirl.create(:public_page, :name => 'News') }
+            let(:element_in_clipboard) { FactoryGirl.create(:element, :page => alchemy_page, :name => 'news') }
+            let(:cell)                 { alchemy_page.cells.first }
+            let(:element)              { FactoryGirl.create(:element, :name => 'news', :page => alchemy_page, :cell => cell) }
 
             before do
               PageLayout.stub(:get).and_return({
@@ -250,7 +250,7 @@ module Alchemy
             end
 
             it "should insert the element at top of list" do
-              post :create, {:element => {:name => 'news', :page_id => page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}##{cell.name}", :format => :js}
+              post :create, {:element => {:name => 'news', :page_id => alchemy_page.id}, :paste_from_clipboard => "#{element_in_clipboard.id}##{cell.name}", :format => :js}
               cell.elements.count.should == 2
               cell.elements.first.name.should == 'news'
               cell.elements.first.should_not == element
@@ -270,7 +270,7 @@ module Alchemy
         end
 
         it "should create an element from clipboard" do
-          post :create, {:paste_from_clipboard => element_in_clipboard.id, :element => {:page_id => page.id}, :format => :js}
+          post :create, {:paste_from_clipboard => element_in_clipboard.id, :element => {:page_id => alchemy_page.id}, :format => :js}
           response.status.should == 200
           response.body.should match(/Succesfully added new element/)
         end
@@ -278,7 +278,7 @@ module Alchemy
         context "and with cut as action parameter" do
 
           it "should also remove the element id from clipboard" do
-            post :create, {:paste_from_clipboard => element_in_clipboard.id, :element => {:page_id => page.id}, :format => :js}
+            post :create, {:paste_from_clipboard => element_in_clipboard.id, :element => {:page_id => alchemy_page.id}, :format => :js}
             session[:clipboard].contains?(:elements, element_in_clipboard.id).should_not be_true
           end
 

data/spec/controllers/admin/pages_controller_spec.rb

@@ -1,3 +1,4 @@
+require 'ostruct'
 require 'spec_helper'
 
 module Alchemy
@@ -36,6 +37,20 @@ module Alchemy
 
     end
 
+    describe "#configure" do
+      render_views
+
+      context "with page having nested urlname" do
+        let(:page) { mock_model(Page, {name: 'Foobar', slug: 'foobar', urlname: 'root/parent/foobar', redirects_to_external?: false, layoutpage?: false, taggable?: false}) }
+
+        it "should always show the slug" do
+          Page.stub!(:find).and_return(page)
+          get :configure, {:id => page.id, :format => :js}
+          response.body.should match /value="foobar"/
+        end
+      end
+    end
+
     describe '#create' do
 
       let(:parent) { FactoryGirl.create(:public_page) }

data/spec/controllers/admin/resources_controller_spec.rb

@@ -1,14 +1,4 @@
-require File.dirname(__FILE__) + "/../../../lib/alchemy/resource"
-require File.dirname(__FILE__) + "/../../../lib/alchemy/resources_helper"
-
-module Alchemy
-  module Admin
-    class ResourcesController
-      helper Alchemy::ResourcesHelper
-    end
-  end
-end
-
+require "spec_helper"
 
 describe Alchemy::Admin::ResourcesController do
   describe "index" do

data/spec/controllers/admin/trash_controller_spec.rb

@@ -7,12 +7,12 @@ module Alchemy
 
       render_views
 
-      let(:page) do
+      let(:alchemy_page) do
         FactoryGirl.create(:page, :parent_id => Page.rootpage.id)
       end
 
       let(:element) do
-        FactoryGirl.create(:element, :public => false, :page => page)
+        FactoryGirl.create(:element, :public => false, :page => alchemy_page)
       end
 
       before do
@@ -21,13 +21,13 @@ module Alchemy
       end
 
       it "should hold trashed elements" do
-        get :index, :page_id => page.id
+        get :index, :page_id => alchemy_page.id
         response.body.should have_selector("#element_#{element.id}.element_editor")
       end
 
       it "should not hold elements that are not trashed" do
-        element = FactoryGirl.create(:element, :page => page, :public => false)
-        get :index, :page_id => page.id
+        element = FactoryGirl.create(:element, :page => alchemy_page, :public => false)
+        get :index, :page_id => alchemy_page.id
         response.body.should_not have_selector("#element_#{element.id}.element_editor")
       end
 
@@ -42,7 +42,7 @@ module Alchemy
         context "and no unique elements on the page" do
 
           it "unique elements should be draggable" do
-            get :index, :page_id => page.id
+            get :index, :page_id => alchemy_page.id
             response.body.should have_selector("#element_#{element.id}.element_editor.draggable")
           end
 
@@ -51,8 +51,8 @@ module Alchemy
         context "and with an unique element on the page" do
 
           it "unique elements should not be draggable" do
-            FactoryGirl.create(:element, :page => page, :public => false)
-            get :index, :page_id => page.id
+            FactoryGirl.create(:element, :page => alchemy_page, :public => false)
+            get :index, :page_id => alchemy_page.id
             response.body.should have_selector("#element_#{element.id}.element_editor.not-draggable")
           end
 
@@ -63,7 +63,7 @@ module Alchemy
       context "#clear" do
 
         it "should destroy all containing elements" do
-          post :clear, {:page_id => page.id, :format => :js}
+          post :clear, {:page_id => alchemy_page.id, :format => :js}
           Element.trashed.should be_empty
         end
 

data/spec/controllers/attachments_controller_spec.rb

@@ -8,9 +8,9 @@ end
 module Alchemy
   describe AttachmentsController do
 
-    let(:page)       { FactoryGirl.create(:public_page, :restricted => true) }
-    let(:element)    { FactoryGirl.create(:element, :page => page, :name => 'download', :create_contents_after_create => true) }
-    let(:attachment) { Attachment.create(:uploaded_data => fixture_file_upload(File.expand_path('../../support/image.png', __FILE__), 'image/png')) }
+    let(:public_page) { FactoryGirl.create(:public_page, :restricted => true) }
+    let(:element)     { FactoryGirl.create(:element, :page => public_page, :name => 'download', :create_contents_after_create => true) }
+    let(:attachment)  { Attachment.create(:file => File.new(File.expand_path('../../support/image.png', __FILE__))) }
 
     before do
       essence = element.contents.where(:name => 'file').first.essence

data/spec/controllers/elements_controller_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 module Alchemy
   describe ElementsController do
 
-    let(:page)                { FactoryGirl.create(:public_page) }
-    let(:element)             { FactoryGirl.create(:element, :page => page, :name => 'download') }
+    let(:public_page)         { FactoryGirl.create(:public_page) }
+    let(:element)             { FactoryGirl.create(:element, :page => public_page, :name => 'download') }
     let(:restricted_page)     { FactoryGirl.create(:public_page, :restricted => true) }
     let(:restricted_element)  { FactoryGirl.create(:element, :page => restricted_page, :name => 'download') }
 

data/spec/controllers/pages_controller_spec.rb

@@ -1,200 +1,231 @@
+require 'ostruct'
 require 'spec_helper'
 
-describe Alchemy::PagesController do
+module Alchemy
+  describe PagesController do
 
-  let(:default_language)      { Alchemy::Language.get_default }
-  let(:default_language_root) { FactoryGirl.create(:language_root_page, :language => default_language, :name => 'Home', :public => true) }
+    let(:default_language)      { Language.get_default }
+    let(:default_language_root) { FactoryGirl.create(:language_root_page, :language => default_language, :name => 'Home', :public => true) }
 
-  context "requested for a page containing a feed" do
-    render_views
+    context "requested for a page containing a feed" do
+      render_views
 
-    let(:page) { FactoryGirl.create(:public_page, :parent_id => default_language_root.id, :page_layout => 'news', :name => 'News', :language => default_language, :do_not_autogenerate => false) }
+      let(:page) { FactoryGirl.create(:public_page, :parent_id => default_language_root.id, :page_layout => 'news', :name => 'News', :language => default_language, :do_not_autogenerate => false) }
 
-    it "should render a rss feed" do
-      get :show, :urlname => page.urlname, :format => :rss
-      response.content_type.should == 'application/rss+xml'
-    end
+      it "should render a rss feed" do
+        get :show, :urlname => page.urlname, :format => :rss
+        response.content_type.should == 'application/rss+xml'
+      end
+
+      it "should include content" do
+        page.elements.first.content_by_name('news_headline').essence.update_attributes({:body => 'Peters Petshop'})
+        get :show, :urlname => 'news', :format => :rss
+        response.body.should match /Peters Petshop/
+      end
 
-    it "should include content" do
-      page.elements.first.content_by_name('news_headline').essence.update_attributes({:body => 'Peters Petshop'})
-      get :show, :urlname => 'news', :format => :rss
-      response.body.should match /Peters Petshop/
     end
 
-  end
+    context "requested for a page that does not contain a feed" do
 
-  context "requested for a page that does not contain a feed" do
+      it "should render xml 404 error" do
+        get :show, :urlname => default_language_root.urlname, :format => :rss
+        response.status.should == 404
+      end
 
-    it "should render xml 404 error" do
-      get :show, :urlname => default_language_root.urlname, :format => :rss
-      response.status.should == 404
     end
 
-  end
+    describe "Layout rendering" do
 
-  describe "Layout rendering" do
+      context "with param layout set to none" do
 
-    context "with param layout set to none" do
+        it "should not render a layout" do
+          get :show, :urlname => :home, :layout => 'none'
+          response.body.should_not match /<head>/
+        end
 
-      it "should not render a layout" do
-        get :show, :urlname => :home, :layout => 'none'
-        response.body.should_not match /<head>/
       end
 
-    end
+      context "with param layout set to false" do
 
-    context "with param layout set to false" do
+        it "should not render a layout" do
+          get :show, :urlname => :home, :layout => 'false'
+          response.body.should_not match /<head>/
+        end
 
-      it "should not render a layout" do
-        get :show, :urlname => :home, :layout => 'false'
-        response.body.should_not match /<head>/
       end
 
-    end
+      context "with params layout set to not existing layout" do
+        it "should raise ActionView::MissingTemplate" do
+          expect {
+            get :show, :urlname => default_language_root.urlname, :layout => 'lkuiuk'
+          }.to raise_error(ActionView::MissingTemplate)
+        end
+      end
+
+      context "with param layout set to a custom layout" do
+        render_views
+
+        before do
+          @custom_layout = Rails.root.join('app/views/layouts', 'custom.html.erb')
+          File.open(@custom_layout, 'w') do |custom_layout|
+            custom_layout.puts "<html>I am a custom layout</html>"
+          end
+        end
+
+        it "should render the custom layout" do
+          get :show, :urlname => default_language_root.urlname, :layout => 'custom'
+          response.body.should have_content('I am a custom layout')
+        end
+
+        after do
+          FileUtils.rm(@custom_layout)
+        end
 
-    context "with params layout set to not existing layout" do
-      it "should raise ActionView::MissingTemplate" do
-        expect {
-          get :show, :urlname => default_language_root.urlname, :layout => 'lkuiuk'
-        }.to raise_error(ActionView::MissingTemplate)
       end
     end
 
-    context "with param layout set to a custom layout" do
+    describe "url nesting" do
       render_views
 
+      let(:catalog)  { FactoryGirl.create(:public_page, :name => "Catalog", :parent_id => default_language_root.id, :language => default_language, :visible => true) }
+      let(:products) { FactoryGirl.create(:public_page, :name => "Products", :parent_id => catalog.id, :language => default_language, :visible => true) }
+      let(:product)  { FactoryGirl.create(:public_page, :name => "Screwdriver", :parent_id => products.id, :language => default_language, :do_not_autogenerate => false, :visible => true) }
+
       before do
-        @custom_layout = Rails.root.join('app/views/layouts', 'custom.html.erb')
-        File.open(@custom_layout, 'w') do |custom_layout|
-          custom_layout.puts "<html>I am a custom layout</html>"
-        end
+        User.stub!(:admins).and_return(OpenStruct.new(count: 1))
+        Config.stub!(:get) { |arg| arg == :url_nesting ? true : false }
+        product.elements.find_by_name('article').contents.essence_texts.first.essence.update_column(:body, 'screwdriver')
       end
 
-      it "should render the custom layout" do
-        get :show, :urlname => default_language_root.urlname, :layout => 'custom'
-        response.body.should have_content('I am a custom layout')
-      end
+      context "with correct levelnames in params" do
 
-      after do
-        FileUtils.rm(@custom_layout)
-      end
-
-    end
-  end
+        it "should show the requested page" do
+          get :show, {:urlname => 'catalog/products/screwdriver'}
+          response.status.should == 200
+          response.body.should have_content("screwdriver")
+        end
 
-  describe "url nesting" do
-    render_views
+      end
 
-    before(:each) do
-      @catalog = FactoryGirl.create(:public_page, :name => "Catalog", :parent_id => default_language_root.id, :language => default_language)
-      @products = FactoryGirl.create(:public_page, :name => "Products", :parent_id => @catalog.id, :language => default_language)
-      @product = FactoryGirl.create(:public_page, :name => "Screwdriver", :parent_id => @products.id, :language => default_language, :do_not_autogenerate => false)
-      @product.elements.find_by_name('article').contents.essence_texts.first.essence.update_column(:body, 'screwdriver')
-      controller.stub!(:configuration) { |arg| arg == :url_nesting ? true : false }
-    end
+      context "with incorrect levelnames in params" do
 
-    context "with correct levelnames in params" do
+        it "should render a 404 page" do
+          get :show, {:urlname => 'catalog/faqs/screwdriver'}
+          response.status.should == 404
+          response.body.should have_content('The page you were looking for doesn\'t exist')
+        end
 
-      it "should show the requested page" do
-        get :show, {:level1 => 'catalog', :level2 => 'products', :urlname => 'screwdriver'}
-        response.status.should == 200
-        response.body.should have_content("screwdriver")
       end
 
     end
 
-    context "with incorrect levelnames in params" do
-
-      it "should render a 404 page" do
-        get :show, {:level1 => 'catalog', :level2 => 'faqs', :urlname => 'screwdriver'}
+    context "when a non-existent page is requested" do
+      it "should rescue a RoutingError with rendering a 404 page." do
+        FactoryGirl.create(:admin_user) # otherwise we are redirected to create_user
+        get :show, {:urlname => 'doesntexist'}
         response.status.should == 404
         response.body.should have_content('The page you were looking for doesn\'t exist')
       end
-
     end
 
-  end
+    describe '#redirect_to_public_child' do
 
-  context "when a non-existent page is requested" do
-    it "should rescue a RoutingError with rendering a 404 page." do
-      FactoryGirl.create(:admin_user) # otherwise we are redirected to create_user
-      get :show, {:urlname => 'doesntexist'}
-      response.status.should == 404
-      response.body.should have_content('The page you were looking for doesn\'t exist')
-    end
-  end
+      let(:root_page)    { FactoryGirl.create(:language_root_page, :public => false) }
+      let(:page)         { FactoryGirl.create(:page, :parent_id => root_page.id) }
+      let(:public_page)  { FactoryGirl.create(:public_page, :parent_id => page.id) }
 
-  describe '#redirect_to_public_child' do
+      before { controller.instance_variable_set("@page", root_page) }
 
-    let(:root_page)    { FactoryGirl.create(:language_root_page, :public => false) }
-    let(:page)         { FactoryGirl.create(:page, :parent_id => root_page.id) }
-    let(:public_page)  { FactoryGirl.create(:public_page, :parent_id => page.id) }
+      context "with unpublished and published pages in page tree" do
 
-    before { controller.instance_variable_set("@page", root_page) }
+        before do
+          public_page
+          root_page.reload
+        end
 
-    context "with unpublished and published pages in page tree" do
+        it "should redirect to first public child" do
+          controller.should_receive(:redirect_page)
+          controller.send(:redirect_to_public_child)
+          controller.instance_variable_get('@page').should == public_page
+        end
 
-      before do
-        public_page
-        root_page.reload
       end
 
-      it "should redirect to first public child" do
-        controller.should_receive(:redirect_page)
-        controller.send(:redirect_to_public_child)
-        controller.instance_variable_get('@page').should == public_page
-      end
+      context "with only unpublished pages in page tree" do
 
-    end
+        before do
+          page
+          root_page.reload
+        end
 
-    context "with only unpublished pages in page tree" do
+        it "should raise not found error" do
+          expect {
+            controller.send(:redirect_to_public_child)
+          }.to raise_error(ActionController::RoutingError)
+        end
 
-      before do
-        page
-        root_page.reload
       end
+    end
 
-      it "should raise not found error" do
-        expect {
-          controller.send(:redirect_to_public_child)
-        }.to raise_error(ActionController::RoutingError)
-      end
+    describe 'Redirecting to legacy page urls' do
+      context 'Request a page with legacy url' do
 
-    end
-  end
+        # otherwise we are redirected to signup
+        before { FactoryGirl.create(:admin_user) }
 
-  describe 'Redirecting to legacy page urls' do
-    context 'Request a page with legacy url' do
+        let(:page)        { FactoryGirl.create(:public_page, :name => 'New page name') }
+        let(:second_page) { FactoryGirl.create(:public_page, :name => 'Second Page') }
+        let(:legacy_page) { FactoryGirl.create(:public_page, :name => 'Legacy Url') }
+        let(:legacy_url)  { LegacyPageUrl.create(:urlname => 'legacy-url', :page => page) }
+        let(:legacy_url2) { LegacyPageUrl.create(:urlname => 'legacy-url', :page => second_page) }
 
-      # otherwise we are redirected to signup
-      before { FactoryGirl.create(:admin_user) }
+        it "should redirect permanently to page that belongs to legacy page url." do
+          get :show, :urlname => legacy_url.urlname
+          response.status.should == 301
+          response.should redirect_to('/new-page-name')
+        end
 
-      let(:page)        { FactoryGirl.create(:public_page, :name => 'New page name') }
-      let(:second_page) { FactoryGirl.create(:public_page, :name => 'Second Page') }
-      let(:legacy_page) { FactoryGirl.create(:public_page, :name => 'Legacy Url') }
-      let(:legacy_url)  { Alchemy::LegacyPageUrl.create(:urlname => 'legacy-url', :page => page) }
-      let(:legacy_url2) { Alchemy::LegacyPageUrl.create(:urlname => 'legacy-url', :page => second_page) }
+        it "should only redirect to legacy url if no page was found for urlname" do
+          legacy_url
+          get :show, :urlname => legacy_page.urlname
+          response.status.should == 200
+          response.should_not redirect_to('/new-page-name')
+        end
 
-      it "should redirect permanently to page that belongs to legacy page url." do
-        get :show, :urlname => legacy_url.urlname
-        response.status.should == 301
-        response.should redirect_to('/alchemy/new-page-name')
-      end
+        it "should redirect to last page that has that legacy url" do
+          legacy_url
+          get :show, :urlname => legacy_url2.urlname
+          response.should redirect_to('/second-page')
+        end
 
-      it "should only redirect to legacy url if no page was found for urlname" do
-        legacy_url
-        get :show, :urlname => legacy_page.urlname
-        response.status.should == 200
-        response.should_not redirect_to('/alchemy/new-page-name')
       end
+    end
+
+    describe "while redirecting" do
+
+      context "not in multi language mode" do
+
+        before do
+          PagesController.any_instance.stub(:multi_language?).and_return(false)
+        end
+
+        context "with no lang parameter present" do
+
+          it "should store defaults language id in the session." do
+            get :show, :urlname => 'a-public-page'
+            controller.session[:language_id].should == Language.get_default.id
+          end
+
+          it "should store defaults language code in the session." do
+            get :show, :urlname => 'a-public-page'
+            controller.session[:language_code].should == Language.get_default.code
+          end
+
+        end
 
-      it "should redirect to last page that has that legacy url" do
-        legacy_url
-        get :show, :urlname => legacy_url2.urlname
-        response.should redirect_to('/alchemy/second-page')
       end
 
     end
-  end
 
+  end
 end