alchemy_cms 3.1.0.rc3 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e14489771d6905de909f3f5e46c0408ff9c739ab
-  data.tar.gz: 9def26e3fdcf006427a909c983a2b0fefa043f04
+  metadata.gz: 1dd3580d83b92bb7990cc1a34e3567ebe037a409
+  data.tar.gz: 88b2975b2529f4a9ec05a780705a8d7d3c193286
 SHA512:
-  metadata.gz: e0d265bd41d9bd04714b910a69027ceaa522ca725dd7fcd216e1ad451f56a76ed78caafc7d56876b4149b49044888bfef5d033b465ece9d16b3337582aad98c6
-  data.tar.gz: 84c1e91cf582a2a0cbebe90436d2a9330d304f678518355fad2007583d08defd9ef29addda9379038fdd973b85da74365e9506186d71b6083cf71e0201f29d98
+  metadata.gz: a8e7aab4bbc54ca64d74829b148921fa122db90f1a7713e4aa554807a74ccd763ac23e97bdc8cad1643c49d4f31448b4d47fc0ff0bb63be9d867534f67935676
+  data.tar.gz: 43a18d1f7f2c31f76fccaa2f7b9afedf32ea6c5f192a65d9ff3aa71fdaeee94ff40e02b0d34e1e6015496c27ca976250ad4108edba0af319f0843e9a0eaedcf1

data/Gemfile

@@ -1,4 +1,4 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
 gemspec
 
@@ -13,7 +13,11 @@ gem 'pg'      if ENV['DB'] == 'postgresql'
 group :development, :test do
   gem 'jasmine-rails',        github: 'searls/jasmine-rails'
   gem 'jasmine-jquery-rails', github: 'travisjeffery/jasmine-jquery-rails'
-  gem 'coveralls',            require: false
+  if ENV['TRAVIS']
+    gem 'coveralls',          require: false
+  else
+    gem 'simplecov',          require: false
+  end
   unless ENV['CI']
     gem 'launchy'
     gem 'annotate'

data/README.md

@@ -1,7 +1,5 @@
 [![Gem Version](https://badge.fury.io/rb/alchemy_cms.svg)](http://badge.fury.io/rb/alchemy_cms)
-[![Build Status](https://travis-ci.org/AlchemyCMS/alchemy_cms.svg?branch=master)](https://travis-ci.org/AlchemyCMS/alchemy_cms) [![Code Climate](https://codeclimate.com/github/AlchemyCMS/alchemy_cms.svg)](https://codeclimate.com/github/AlchemyCMS/alchemy_cms) [![Coverage Status](https://img.shields.io/coveralls/AlchemyCMS/alchemy_cms.svg)](https://coveralls.io/r/AlchemyCMS/alchemy_cms?branch=master)
-
-**CAUTION: This master branch is a development branch that can contain bugs. For productive environments you should use the [current Ruby gem version](https://rubygems.org/gems/alchemy_cms/versions/3.0.0), or the [latest stable branch (3.0-stable)](https://github.com/AlchemyCMS/alchemy_cms/tree/3.0-stable).**
+[![Build Status](https://travis-ci.org/AlchemyCMS/alchemy_cms.svg?branch=3.1-stable)](https://travis-ci.org/AlchemyCMS/alchemy_cms) [![Code Climate](https://codeclimate.com/github/AlchemyCMS/alchemy_cms.svg)](https://codeclimate.com/github/AlchemyCMS/alchemy_cms) [![Coverage Status](https://img.shields.io/coveralls/AlchemyCMS/alchemy_cms.svg)](https://coveralls.io/r/AlchemyCMS/alchemy_cms?branch=3.1-stable)
 
 
 ## About
@@ -33,8 +31,7 @@ Read more about Alchemy on the [website](http://alchemy-cms.com) and in the [gui
 
 **This version of Alchemy CMS runs with Rails 4 (including 4.1)**
 
-**Rails 4.2 support is coming soon. Watch [this pull request](https://github.com/AlchemyCMS/alchemy_cms/pull/655).**
-
+* For Rails 4.2 support use the current [master branch](https://github.com/AlchemyCMS/alchemy_cms/tree/master).
 * For a Rails 3.2 compatible version use the [`2.8-stable` branch](https://github.com/AlchemyCMS/alchemy_cms/tree/2.8-stable).
 * For a Rails 3.1 compatible version use the [`2.1-stable` branch](https://github.com/AlchemyCMS/alchemy_cms/tree/2.1-stable).
 * For a Rails 3.0 compatible version use the [`2.0-stable` branch](https://github.com/AlchemyCMS/alchemy_cms/tree/2.0-stable).
@@ -55,7 +52,7 @@ For a Ruby 1.8.7 compatible version use the [`2.3-stable` branch](https://github
 Use the installer:
 
 ```shell
-$ gem install alchemy_cms --pre
+$ gem install alchemy_cms
 $ alchemy new my_magicpage
 ```
 
@@ -74,11 +71,9 @@ $ alchemy --help
 Put this into your `Gemfile`:
 
 ```ruby
-gem 'alchemy_cms', github: 'AlchemyCMS/alchemy_cms', branch: 'master'
+gem 'alchemy_cms', github: 'AlchemyCMS/alchemy_cms', branch: '3.1-stable'
 ```
 
-**NOTE:** You normally want to use a stable branch, like `3.0-stable`.
-
 If you want to use Russian translation and have better i18n support, you should put:
 
 ```ruby
@@ -103,16 +98,14 @@ the Devise based user model that Alchemy provides and was extracted [into its ow
 If you don't have your own user class, you can use the Alchemy user model. Just add the following gem into your `Gemfile`:
 
 ```ruby
-gem 'alchemy-devise', github: 'AlchemyCMS/alchemy-devise', branch: 'master'
+gem 'alchemy-devise', github: 'AlchemyCMS/alchemy-devise', branch: '2.1-stable'
 ```
 
-**NOTE:** You normally want to use a stable branch, like `2.0-stable`.
-
 Then run:
 
 ```shell
 $ bundle install
-$ bin/rake alchemy_devise:install:migrations
+$ bin/rails g alchemy:devise:install
 ```
 
 ##### Use your User model
@@ -123,10 +116,11 @@ The best practice is to use an initializer:
 
 ```ruby
 # config/initializers/alchemy.rb
-Alchemy.user_class_name = 'YourUserClass'       # Defaults to 'User'
-Alchemy.signup_path     = '/your/signup/path'   # Defaults to '/signup'
-Alchemy.login_path      = '/your/login/path'    # Defaults to '/login'
-Alchemy.logout_path     = '/your/logout/path'   # Defaults to '/logout'
+Alchemy.user_class_name     = 'YourUserClass'       # Defaults to 'User'
+Alchemy.current_user_method = 'current_admin_user'  # Defaults to 'current_user'
+Alchemy.signup_path         = '/your/signup/path'   # Defaults to '/signup'
+Alchemy.login_path          = '/your/login/path'    # Defaults to '/login'
+Alchemy.logout_path         = '/your/logout/path'   # Defaults to '/logout'
 ```
 
 The only thing Alchemy needs to know from your user class is the `alchemy_roles` method.

data/app/controllers/alchemy/admin/pages_controller.rb

@@ -12,9 +12,11 @@ module Alchemy
       before_action :set_root_page,
         only: [:index, :show, :sort, :order]
 
-      authorize_resource class: Alchemy::Page
+      authorize_resource class: Alchemy::Page, except: :index
 
       def index
+        authorize! :index, :alchemy_admin_pages
+
         @locked_pages = Page.from_current_site.all_locked_by(current_alchemy_user)
         @languages = Language.all
         if !@page_root

data/db/migrate/20130827094554_alchemy_two_point_six.rb

@@ -310,6 +310,88 @@ class AlchemyTwoPointSix < ActiveRecord::Migration
         t.string "name"
       end
     end
+  end
+
+  def down
+    if table_exists?('alchemy_attachments')
+      drop_table "alchemy_attachments"
+    end
+
+    if table_exists?('alchemy_cells')
+      drop_table "alchemy_cells"
+    end
+
+    if table_exists?('alchemy_contents')
+      drop_table "alchemy_contents"
+    end
+
+    if table_exists?('alchemy_elements')
+      drop_table "alchemy_elements"
+    end
+
+    if table_exists?('alchemy_elements_alchemy_pages')
+      drop_table "alchemy_elements_alchemy_pages"
+    end
+
+    if table_exists?('alchemy_essence_booleans')
+      drop_table "alchemy_essence_booleans"
+    end
+
+    if table_exists?('alchemy_essence_dates')
+      drop_table "alchemy_essence_dates"
+    end
+
+    if table_exists?('alchemy_essence_files')
+      drop_table "alchemy_essence_files"
+    end
+
+    if table_exists?('alchemy_essence_htmls')
+      drop_table "alchemy_essence_htmls"
+    end
+
+    if table_exists?('alchemy_essence_links')
+      drop_table "alchemy_essence_links"
+    end
+
+    if table_exists?('alchemy_essence_pictures')
+      drop_table "alchemy_essence_pictures"
+    end
+
+    if table_exists?('alchemy_essence_richtexts')
+      drop_table "alchemy_essence_richtexts"
+    end
+
+    if table_exists?('alchemy_essence_selects')
+      drop_table "alchemy_essence_selects"
+    end
+
+    if table_exists?('alchemy_essence_texts')
+      drop_table "alchemy_essence_texts"
+    end
+
+    if table_exists?('alchemy_folded_pages')
+      drop_table "alchemy_folded_pages"
+    end
+
+    if table_exists?('alchemy_languages')
+      drop_table "alchemy_languages"
+    end
+
+    if table_exists?('alchemy_legacy_page_urls')
+      drop_table "alchemy_legacy_page_urls"
+    end
+
+    if table_exists?('alchemy_pages')
+      drop_table "alchemy_pages"
+    end
+
+    if table_exists?('alchemy_pictures')
+      drop_table "alchemy_pictures"
+    end
+
+    if table_exists?('alchemy_sites')
+      drop_table "alchemy_sites"
+    end
 
   end
 end

data/lib/alchemy/auth_accessors.rb

@@ -3,6 +3,7 @@
 # Alchemy has some defaults for user model name and login logout path names:
 #
 # +Alchemy.user_class_name+ defaults to +'User'+
+# +Alchemy.current_user_method defaults to +'current_user'+
 # +Alchemy.signup_path defaults to +'/signup'+
 # +Alchemy.login_path defaults to +'/login'+
 # +Alchemy.logout_path defaults to +'/logout'+
@@ -10,14 +11,17 @@
 # Anyway, you can tell Alchemy about your authentication model configuration:
 #
 #   1. Your user class name - @see: Alchemy.user_class
-#   2. The path to the signup form - @see: Alchemy.signup_path
-#   3. The path to the login form - @see: Alchemy.login_path
-#   4. The path to the logout method - @see: Alchemy.logout_path
+#   2. A method on your ApplicationController to get current user -
+#      @see: Alchemy.current_user_method
+#   3. The path to the signup form - @see: Alchemy.signup_path
+#   4. The path to the login form - @see: Alchemy.login_path
+#   5. The path to the logout method - @see: Alchemy.logout_path
 #
 # == Example
 #
 #     # config/initializers/alchemy.rb
 #     Alchemy.user_class_name = 'Admin'
+#     Alchemy.current_user_method = 'current_admin'
 #     Alchemy.signup_path = '/auth/signup'
 #     Alchemy.login_path = '/auth/login'
 #     Alchemy.logout_path = '/auth/logout'

data/lib/alchemy/version.rb

@@ -1,5 +1,5 @@
 module Alchemy
-  VERSION = "3.1.0.rc3"
+  VERSION = "3.1.0"
 
   def self.version
     VERSION

data/spec/controllers/admin/pages_controller_spec.rb

@@ -3,532 +3,551 @@ require 'spec_helper'
 
 module Alchemy
   describe Admin::PagesController do
-    let(:user) { editor_user }
-    before { sign_in(user) }
 
-    describe '#index' do
-      let(:language)      { build_stubbed(:language) }
-      let(:language_root) { build_stubbed(:language_root_page) }
-
-      context 'with existing language root page' do
-        before do
-          expect(Language).to receive(:current_root_page).and_return(language_root)
-        end
-
-        it "assigns @page_root variable" do
-          get :index
-          expect(assigns(:page_root)).to be(language_root)
-        end
+    context 'a guest' do
+      it 'can not access page tree' do
+        get :index
+        expect(request).to redirect_to(Alchemy.login_path)
       end
+    end
 
-      context 'without language root page' do
-        before do
-          expect(Language).to receive(:current_root_page).and_return(nil)
-          expect(Language).to receive(:find_by).and_return(language)
-          expect(Language).to receive(:all).and_return([language])
-          expect(Language).to receive(:with_root_page).and_return([language])
-        end
+    context 'a member' do
+      before { sign_in(member_user) }
 
-        it "it assigns current language" do
-          get :index
-          expect(assigns(:language)).to be(language)
-        end
+      it 'can not access page tree' do
+        get :index
+        expect(request).to redirect_to(root_path)
       end
     end
 
-    describe "#flush" do
-      let(:language) { mock_model('Language', code: 'en', pages: double(flushables: [page_1, page_2])) }
-      let(:page_1)   { build_stubbed(:page) }
-      let(:page_2)   { build_stubbed(:page) }
+    context 'with logged in editor user' do
+      let(:user) { editor_user }
 
-      before do
-        expect(Language).to receive(:current).at_least(:once).and_return(language)
-      end
+      before { sign_in(user) }
 
-      it "should remove the cache of all pages" do
-        expect(page_1).to receive(:publish!)
-        expect(page_2).to receive(:publish!)
-        xhr :post, :flush
-      end
-    end
+      describe '#index' do
+        let(:language)      { build_stubbed(:language) }
+        let(:language_root) { build_stubbed(:language_root_page) }
 
-    describe '#new' do
-      context "pages in clipboard" do
-        let(:clipboard) { session[:alchemy_clipboard] = {} }
-        let(:page) { mock_model(Alchemy::Page, name: 'Foobar') }
+        context 'with existing language root page' do
+          before do
+            expect(Language).to receive(:current_root_page).and_return(language_root)
+          end
 
-        before { clipboard['pages'] = [{'id' => page.id.to_s, 'action' => 'copy'}] }
+          it "assigns @page_root variable" do
+            get :index
+            expect(assigns(:page_root)).to be(language_root)
+          end
+        end
 
-        it "should load all pages from clipboard" do
-          xhr :get, :new, {page_id: page.id}
-          expect(assigns(:clipboard_items)).to be_kind_of(Array)
+        context 'without language root page' do
+          before do
+            expect(Language).to receive(:current_root_page).and_return(nil)
+            expect(Language).to receive(:find_by).and_return(language)
+            expect(Language).to receive(:all).and_return([language])
+            expect(Language).to receive(:with_root_page).and_return([language])
+          end
+
+          it "it assigns current language" do
+            get :index
+            expect(assigns(:language)).to be(language)
+          end
         end
       end
-    end
 
-    describe '#show' do
-      let(:page) { build_stubbed(:page, language_code: 'nl') }
+      describe "#flush" do
+        let(:language) { mock_model('Language', code: 'en', pages: double(flushables: [page_1, page_2])) }
+        let(:page_1)   { build_stubbed(:page) }
+        let(:page_2)   { build_stubbed(:page) }
 
-      before do
-        expect(Page).to receive(:find).with("#{page.id}").and_return(page)
-        allow(Page).to receive(:language_root_for).and_return(mock_model(Alchemy::Page))
-      end
+        before do
+          expect(Language).to receive(:current).at_least(:once).and_return(language)
+        end
 
-      it "should assign @preview_mode with true" do
-        get :show, id: page.id
-        expect(assigns(:preview_mode)).to eq(true)
+        it "should remove the cache of all pages" do
+          expect(page_1).to receive(:publish!)
+          expect(page_2).to receive(:publish!)
+          xhr :post, :flush
+        end
       end
 
-      it "should store page as current preview" do
-        Page.current_preview = nil
-        get :show, id: page.id
-        expect(Page.current_preview).to eq(page)
-      end
+      describe '#new' do
+        context "pages in clipboard" do
+          let(:clipboard) { session[:alchemy_clipboard] = {} }
+          let(:page) { mock_model(Alchemy::Page, name: 'Foobar') }
 
-      it "should set the I18n locale to the pages language code" do
-        get :show, id: page.id
-        expect(::I18n.locale).to eq(:nl)
-      end
+          before { clipboard['pages'] = [{'id' => page.id.to_s, 'action' => 'copy'}] }
 
-      it "renders the application layout" do
-        get :show, id: page.id
-        expect(response).to render_template(layout: 'application')
+          it "should load all pages from clipboard" do
+            xhr :get, :new, {page_id: page.id}
+            expect(assigns(:clipboard_items)).to be_kind_of(Array)
+          end
+        end
       end
-    end
 
-    describe '#order' do
-      let(:page_1)       { FactoryGirl.create(:page, visible: true) }
-      let(:page_2)       { FactoryGirl.create(:page, visible: true) }
-      let(:page_3)       { FactoryGirl.create(:page, visible: true) }
-      let(:page_item_1)  { {id: page_1.id, slug: page_1.slug, restricted: false, external: page_1.redirects_to_external?, visible: page_1.visible?, children: [page_item_2]} }
-      let(:page_item_2)  { {id: page_2.id, slug: page_2.slug, restricted: false, external: page_2.redirects_to_external?, visible: page_2.visible?, children: [page_item_3]} }
-      let(:page_item_3)  { {id: page_3.id, slug: page_3.slug, restricted: false, external: page_3.redirects_to_external?, visible: page_3.visible? } }
-      let(:set_of_pages) { [page_item_1] }
-
-      it "stores the new order" do
-        xhr :post, :order, set: set_of_pages.to_json
-        page_1.reload
-        expect(page_1.descendants).to eq([page_2, page_3])
-      end
+      describe '#show' do
+        let(:page) { build_stubbed(:page, language_code: 'nl') }
 
-      context 'with url nesting enabled' do
         before do
-          expect(Alchemy::Config).to receive(:get).with(:url_nesting).at_least(:once).and_return(true)
+          expect(Page).to receive(:find).with("#{page.id}").and_return(page)
+          allow(Page).to receive(:language_root_for).and_return(mock_model(Alchemy::Page))
+        end
+
+        it "should assign @preview_mode with true" do
+          get :show, id: page.id
+          expect(assigns(:preview_mode)).to eq(true)
+        end
+
+        it "should store page as current preview" do
+          Page.current_preview = nil
+          get :show, id: page.id
+          expect(Page.current_preview).to eq(page)
         end
 
-        it "updates the pages urlnames" do
+        it "should set the I18n locale to the pages language code" do
+          get :show, id: page.id
+          expect(::I18n.locale).to eq(:nl)
+        end
+
+        it "renders the application layout" do
+          get :show, id: page.id
+          expect(response).to render_template(layout: 'application')
+        end
+      end
+
+      describe '#order' do
+        let(:page_1)       { FactoryGirl.create(:page, visible: true) }
+        let(:page_2)       { FactoryGirl.create(:page, visible: true) }
+        let(:page_3)       { FactoryGirl.create(:page, visible: true) }
+        let(:page_item_1)  { {id: page_1.id, slug: page_1.slug, restricted: false, external: page_1.redirects_to_external?, visible: page_1.visible?, children: [page_item_2]} }
+        let(:page_item_2)  { {id: page_2.id, slug: page_2.slug, restricted: false, external: page_2.redirects_to_external?, visible: page_2.visible?, children: [page_item_3]} }
+        let(:page_item_3)  { {id: page_3.id, slug: page_3.slug, restricted: false, external: page_3.redirects_to_external?, visible: page_3.visible? } }
+        let(:set_of_pages) { [page_item_1] }
+
+        it "stores the new order" do
           xhr :post, :order, set: set_of_pages.to_json
-          [page_1, page_2, page_3].map(&:reload)
-          expect(page_1.urlname).to eq("#{page_1.slug}")
-          expect(page_2.urlname).to eq("#{page_1.slug}/#{page_2.slug}")
-          expect(page_3.urlname).to eq("#{page_1.slug}/#{page_2.slug}/#{page_3.slug}")
+          page_1.reload
+          expect(page_1.descendants).to eq([page_2, page_3])
         end
 
-        context 'with invisible page in tree' do
-          let(:page_item_2) do
-            {
-              id: page_2.id,
-              slug: page_2.slug,
-              children: [page_item_3],
-              visible: false
-            }
+        context 'with url nesting enabled' do
+          before do
+            expect(Alchemy::Config).to receive(:get).with(:url_nesting).at_least(:once).and_return(true)
           end
 
-          it "does not use this pages slug in urlnames of descendants" do
+          it "updates the pages urlnames" do
             xhr :post, :order, set: set_of_pages.to_json
             [page_1, page_2, page_3].map(&:reload)
             expect(page_1.urlname).to eq("#{page_1.slug}")
             expect(page_2.urlname).to eq("#{page_1.slug}/#{page_2.slug}")
-            expect(page_3.urlname).to eq("#{page_1.slug}/#{page_3.slug}")
+            expect(page_3.urlname).to eq("#{page_1.slug}/#{page_2.slug}/#{page_3.slug}")
           end
-        end
 
-        context 'with external page in tree' do
-          let(:page_item_2) do
-            {
-              id: page_2.id,
-              slug: page_2.slug,
-              children: [page_item_3],
-              external: true
-            }
-          end
+          context 'with invisible page in tree' do
+            let(:page_item_2) do
+              {
+                id: page_2.id,
+                slug: page_2.slug,
+                children: [page_item_3],
+                visible: false
+              }
+            end
 
-          it "does not use this pages slug in urlnames of descendants" do
-            xhr :post, :order, set: set_of_pages.to_json
-            [page_1, page_2, page_3].map(&:reload)
-            expect(page_3.urlname).to eq("#{page_1.slug}/#{page_3.slug}")
+            it "does not use this pages slug in urlnames of descendants" do
+              xhr :post, :order, set: set_of_pages.to_json
+              [page_1, page_2, page_3].map(&:reload)
+              expect(page_1.urlname).to eq("#{page_1.slug}")
+              expect(page_2.urlname).to eq("#{page_1.slug}/#{page_2.slug}")
+              expect(page_3.urlname).to eq("#{page_1.slug}/#{page_3.slug}")
+            end
           end
-        end
 
-        context 'with restricted page in tree' do
-          let(:page_2) { FactoryGirl.create(:page, restricted: true) }
-          let(:page_item_2) do
-            {
-              id: page_2.id,
-              slug: page_2.slug,
-              children: [page_item_3],
-              restricted: true
-            }
-          end
+          context 'with external page in tree' do
+            let(:page_item_2) do
+              {
+                id: page_2.id,
+                slug: page_2.slug,
+                children: [page_item_3],
+                external: true
+              }
+            end
 
-          it "updates restricted status of descendants" do
-            xhr :post, :order, set: set_of_pages.to_json
-            page_3.reload
-            expect(page_3.restricted).to be_truthy
+            it "does not use this pages slug in urlnames of descendants" do
+              xhr :post, :order, set: set_of_pages.to_json
+              [page_1, page_2, page_3].map(&:reload)
+              expect(page_3.urlname).to eq("#{page_1.slug}/#{page_3.slug}")
+            end
           end
-        end
 
-        context 'with page having number as slug' do
-          let(:page_item_2) do
-            {
-              id: page_2.id,
-              slug: 42,
-              children: [page_item_3]
-            }
+          context 'with restricted page in tree' do
+            let(:page_2) { FactoryGirl.create(:page, restricted: true) }
+            let(:page_item_2) do
+              {
+                id: page_2.id,
+                slug: page_2.slug,
+                children: [page_item_3],
+                restricted: true
+              }
+            end
+
+            it "updates restricted status of descendants" do
+              xhr :post, :order, set: set_of_pages.to_json
+              page_3.reload
+              expect(page_3.restricted).to be_truthy
+            end
           end
 
-          it "does not raise error" do
-            expect {
+          context 'with page having number as slug' do
+            let(:page_item_2) do
+              {
+                id: page_2.id,
+                slug: 42,
+                children: [page_item_3]
+              }
+            end
+
+            it "does not raise error" do
+              expect {
+                xhr :post, :order, set: set_of_pages.to_json
+              }.not_to raise_error
+            end
+
+            it "still generates the correct urlname on page_3" do
               xhr :post, :order, set: set_of_pages.to_json
-            }.not_to raise_error
+              [page_1, page_2, page_3].map(&:reload)
+              expect(page_3.urlname).to eq("#{page_1.slug}/#{page_2.slug}/#{page_3.slug}")
+            end
           end
 
-          it "still generates the correct urlname on page_3" do
+          it "creates legacy urls" do
             xhr :post, :order, set: set_of_pages.to_json
-            [page_1, page_2, page_3].map(&:reload)
-            expect(page_3.urlname).to eq("#{page_1.slug}/#{page_2.slug}/#{page_3.slug}")
+            [page_2, page_3].map(&:reload)
+            expect(page_2.legacy_urls.size).to eq(1)
+            expect(page_3.legacy_urls.size).to eq(1)
           end
         end
-
-        it "creates legacy urls" do
-          xhr :post, :order, set: set_of_pages.to_json
-          [page_2, page_3].map(&:reload)
-          expect(page_2.legacy_urls.size).to eq(1)
-          expect(page_3.legacy_urls.size).to eq(1)
-        end
       end
-    end
 
-    describe "#configure" do
-      render_views
+      describe "#configure" do
+        render_views
 
-      context "with page having nested urlname" do
-        let(:page) { create(:page, name: 'Foobar') }
+        context "with page having nested urlname" do
+          let(:page) { create(:page, name: 'Foobar') }
 
-        it "should always show the slug" do
-          xhr :get, :configure, {id: page.id}
-          expect(response.body).to match /value="foobar"/
+          it "should always show the slug" do
+            xhr :get, :configure, {id: page.id}
+            expect(response.body).to match /value="foobar"/
+          end
         end
       end
-    end
 
-    describe '#create' do
-      let(:language)    { mock_model('Language', code: 'kl') }
-      let(:parent)      { mock_model('Page', language: language) }
-      let(:page_params) { {parent_id: parent.id, name: 'new Page'} }
+      describe '#create' do
+        let(:language)    { mock_model('Language', code: 'kl') }
+        let(:parent)      { mock_model('Page', language: language) }
+        let(:page_params) { {parent_id: parent.id, name: 'new Page'} }
 
-      context "a new page" do
-        before do
-          allow_any_instance_of(Page).to receive(:set_language_from_parent_or_default)
-          allow_any_instance_of(Page).to receive(:save).and_return(true)
-        end
-
-        it "is nested under given parent" do
-          allow(controller).to receive(:edit_admin_page_path).and_return('bla')
-          xhr :post, :create, {page: page_params}
-          expect(assigns(:page).parent_id).to eq(parent.id)
-        end
-
-        it "redirects to edit page template" do
-          page = mock_model('Page')
-          expect(controller).to receive(:edit_admin_page_path).and_return('bla')
-          post :create, page: page_params
-          expect(response).to redirect_to('bla')
-        end
+        context "a new page" do
+          before do
+            allow_any_instance_of(Page).to receive(:set_language_from_parent_or_default)
+            allow_any_instance_of(Page).to receive(:save).and_return(true)
+          end
 
-        context "if new page can not be saved" do
-          it "renders the create form" do
-            allow_any_instance_of(Page).to receive(:save).and_return(false)
-            post :create, page: {name: 'page'}
-            expect(response).to render_template('new')
+          it "is nested under given parent" do
+            allow(controller).to receive(:edit_admin_page_path).and_return('bla')
+            xhr :post, :create, {page: page_params}
+            expect(assigns(:page).parent_id).to eq(parent.id)
           end
-        end
 
-        context "with redirect_to in params" do
-          let(:page_params) do
-            {name: "Foobar", page_layout: 'standard', parent_id: parent.id}
+          it "redirects to edit page template" do
+            page = mock_model('Page')
+            expect(controller).to receive(:edit_admin_page_path).and_return('bla')
+            post :create, page: page_params
+            expect(response).to redirect_to('bla')
           end
 
-          it "should redirect to given url" do
-            post :create, page: page_params, redirect_to: admin_pictures_path
-            expect(response).to redirect_to(admin_pictures_path)
+          context "if new page can not be saved" do
+            it "renders the create form" do
+              allow_any_instance_of(Page).to receive(:save).and_return(false)
+              post :create, page: {name: 'page'}
+              expect(response).to render_template('new')
+            end
           end
 
-          context "but new page can not be saved" do
-            render_views
+          context "with redirect_to in params" do
+            let(:page_params) do
+              {name: "Foobar", page_layout: 'standard', parent_id: parent.id}
+            end
 
-            it "should render the `new` template" do
-              allow_any_instance_of(Page).to receive(:save).and_return(false)
-              xhr :post, :create, page: {name: 'page'}, redirect_to: admin_pictures_path
-              expect(response.body).to match /form.+action=\"\/admin\/pages\"/
+            it "should redirect to given url" do
+              post :create, page: page_params, redirect_to: admin_pictures_path
+              expect(response).to redirect_to(admin_pictures_path)
+            end
+
+            context "but new page can not be saved" do
+              render_views
+
+              it "should render the `new` template" do
+                allow_any_instance_of(Page).to receive(:save).and_return(false)
+                xhr :post, :create, page: {name: 'page'}, redirect_to: admin_pictures_path
+                expect(response.body).to match /form.+action=\"\/admin\/pages\"/
+              end
+            end
+          end
+
+          context 'with page redirecting to external' do
+            it "redirects to sitemap" do
+              expect_any_instance_of(Page).to receive(:redirects_to_external?).and_return(true)
+              post :create, page: page_params
+              expect(response).to redirect_to(admin_pages_path)
             end
           end
         end
 
-        context 'with page redirecting to external' do
-          it "redirects to sitemap" do
-            expect_any_instance_of(Page).to receive(:redirects_to_external?).and_return(true)
-            post :create, page: page_params
-            expect(response).to redirect_to(admin_pages_path)
+        context "with paste_from_clipboard in parameters" do
+          let(:page_in_clipboard) { mock_model(Alchemy::Page) }
+
+          before do
+            allow(Page).to receive(:find_by).with(id: "#{parent.id}").and_return(parent)
+            allow(Page).to receive(:find).with("#{page_in_clipboard.id}").and_return(page_in_clipboard)
+          end
+
+          it "should call Page#copy_and_paste" do
+            expect(Page).to receive(:copy_and_paste).with(
+              page_in_clipboard,
+              parent,
+              'pasted Page'
+            ).and_return(
+              mock_model('Page', save: true, name: 'pasted Page', redirects_to_external?: false)
+            )
+            xhr :post, :create, {paste_from_clipboard: page_in_clipboard.id, page: {parent_id: parent.id, name: 'pasted Page'}}
           end
         end
       end
 
-      context "with paste_from_clipboard in parameters" do
-        let(:page_in_clipboard) { mock_model(Alchemy::Page) }
+      describe '#copy_language_tree' do
+        let(:params)                     { {languages: {new_lang_id: '2', old_lang_id: '1'}} }
+        let(:language_root_to_copy_from) { build_stubbed(:language_root_page) }
+        let(:copy_of_language_root)      { build_stubbed(:language_root_page) }
+        let(:root_page)                  { mock_model('Page') }
 
         before do
-          allow(Page).to receive(:find_by).with(id: "#{parent.id}").and_return(parent)
-          allow(Page).to receive(:find).with("#{page_in_clipboard.id}").and_return(page_in_clipboard)
+          allow(Page).to receive(:copy).and_return(copy_of_language_root)
+          allow(Page).to receive(:root).and_return(root_page)
+          allow(Page).to receive(:language_root_for).and_return(language_root_to_copy_from)
+          allow_any_instance_of(Page).to receive(:move_to_child_of)
+          allow_any_instance_of(Page).to receive(:copy_children_to)
+          allow(controller).to receive(:store_current_language)
+          allow(Language).to receive(:current).and_return(mock_model('Language', language_code: 'it', code: 'it'))
         end
 
-        it "should call Page#copy_and_paste" do
-          expect(Page).to receive(:copy_and_paste).with(
-            page_in_clipboard,
-            parent,
-            'pasted Page'
-          ).and_return(
-            mock_model('Page', save: true, name: 'pasted Page', redirects_to_external?: false)
-          )
-          xhr :post, :create, {paste_from_clipboard: page_in_clipboard.id, page: {parent_id: parent.id, name: 'pasted Page'}}
+        it "should copy the language root page over to the other language" do
+          expect(Page).to receive(:copy).with(language_root_to_copy_from, {language_id: '2', language_code: 'it'})
+          post :copy_language_tree, params
         end
-      end
-    end
 
-    describe '#copy_language_tree' do
-      let(:params)                     { {languages: {new_lang_id: '2', old_lang_id: '1'}} }
-      let(:language_root_to_copy_from) { build_stubbed(:language_root_page) }
-      let(:copy_of_language_root)      { build_stubbed(:language_root_page) }
-      let(:root_page)                  { mock_model('Page') }
-
-      before do
-        allow(Page).to receive(:copy).and_return(copy_of_language_root)
-        allow(Page).to receive(:root).and_return(root_page)
-        allow(Page).to receive(:language_root_for).and_return(language_root_to_copy_from)
-        allow_any_instance_of(Page).to receive(:move_to_child_of)
-        allow_any_instance_of(Page).to receive(:copy_children_to)
-        allow(controller).to receive(:store_current_language)
-        allow(Language).to receive(:current).and_return(mock_model('Language', language_code: 'it', code: 'it'))
-      end
+        it "should move the newly created language-root-page below the absolute root page" do
+          expect(copy_of_language_root).to receive(:move_to_child_of).with(root_page)
+          post :copy_language_tree, params
+        end
 
-      it "should copy the language root page over to the other language" do
-        expect(Page).to receive(:copy).with(language_root_to_copy_from, {language_id: '2', language_code: 'it'})
-        post :copy_language_tree, params
-      end
+        it "should copy all childs of the original page over to the new created one" do
+          expect(controller).to receive(:language_root_to_copy_from).and_return(language_root_to_copy_from)
+          expect(controller).to receive(:copy_of_language_root).and_return(copy_of_language_root)
+          expect(language_root_to_copy_from).to receive(:copy_children_to).with(copy_of_language_root)
+          post :copy_language_tree, params
+        end
 
-      it "should move the newly created language-root-page below the absolute root page" do
-        expect(copy_of_language_root).to receive(:move_to_child_of).with(root_page)
-        post :copy_language_tree, params
+        it "should redirect to admin_pages_path" do
+          allow(controller).to receive(:copy_of_language_root)
+          allow(controller).to receive(:language_root_to_copy_from).and_return(double(copy_children_to: nil))
+          post :copy_language_tree, params
+          expect(response).to redirect_to(admin_pages_path)
+        end
       end
 
-      it "should copy all childs of the original page over to the new created one" do
-        expect(controller).to receive(:language_root_to_copy_from).and_return(language_root_to_copy_from)
-        expect(controller).to receive(:copy_of_language_root).and_return(copy_of_language_root)
-        expect(language_root_to_copy_from).to receive(:copy_children_to).with(copy_of_language_root)
-        post :copy_language_tree, params
-      end
+      describe '#edit' do
+        let!(:page)       { create(:page) }
+        let!(:other_user) { create(:author_user) }
 
-      it "should redirect to admin_pages_path" do
-        allow(controller).to receive(:copy_of_language_root)
-        allow(controller).to receive(:language_root_to_copy_from).and_return(double(copy_children_to: nil))
-        post :copy_language_tree, params
-        expect(response).to redirect_to(admin_pages_path)
-      end
-    end
+        context 'if page is locked by another user' do
+          before { page.lock_to!(other_user) }
+
+          context 'that is signed in' do
+            before do
+              expect_any_instance_of(DummyUser).to receive(:logged_in?).and_return(true)
+            end
 
-    describe '#edit' do
-      let!(:page)       { create(:page) }
-      let!(:other_user) { create(:author_user) }
+            it 'redirects to sitemap' do
+              get :edit, id: page.id
+              expect(response).to redirect_to(admin_pages_path)
+            end
+          end
 
-      context 'if page is locked by another user' do
-        before { page.lock_to!(other_user) }
+          context 'that is not signed in' do
+            before do
+              expect_any_instance_of(DummyUser).to receive(:logged_in?).and_return(false)
+            end
+
+            it 'renders the edit view' do
+              get :edit, id: page.id
+              expect(response).to render_template(:edit)
+            end
+          end
+        end
 
-        context 'that is signed in' do
+        context 'if page is locked by myself' do
           before do
-            expect_any_instance_of(DummyUser).to receive(:logged_in?).and_return(true)
+            expect_any_instance_of(Page).to receive(:locker).and_return(user)
+            expect(user).to receive(:logged_in?).and_return(true)
           end
 
-          it 'redirects to sitemap' do
+          it 'renders the edit view' do
             get :edit, id: page.id
-            expect(response).to redirect_to(admin_pages_path)
+            expect(response).to render_template(:edit)
           end
         end
 
-        context 'that is not signed in' do
+        context 'if page is not locked' do
           before do
-            expect_any_instance_of(DummyUser).to receive(:logged_in?).and_return(false)
+            expect_any_instance_of(Page).to receive(:locker).and_return(nil)
           end
 
           it 'renders the edit view' do
             get :edit, id: page.id
             expect(response).to render_template(:edit)
           end
-        end
-      end
 
-      context 'if page is locked by myself' do
-        before do
-          expect_any_instance_of(Page).to receive(:locker).and_return(user)
-          expect(user).to receive(:logged_in?).and_return(true)
-        end
-
-        it 'renders the edit view' do
-          get :edit, id: page.id
-          expect(response).to render_template(:edit)
+          it "lockes the page to myself" do
+            expect_any_instance_of(Page).to receive(:lock_to!)
+            get :edit, id: page.id
+          end
         end
       end
 
-      context 'if page is not locked' do
-        before do
-          expect_any_instance_of(Page).to receive(:locker).and_return(nil)
-        end
+      describe '#destroy' do
+        let(:clipboard) { session[:alchemy_clipboard] = {} }
+        let(:page) { FactoryGirl.create(:public_page) }
 
-        it 'renders the edit view' do
-          get :edit, id: page.id
-          expect(response).to render_template(:edit)
-        end
+        before { clipboard['pages'] = [{'id' => page.id.to_s}] }
 
-        it "lockes the page to myself" do
-          expect_any_instance_of(Page).to receive(:lock_to!)
-          get :edit, id: page.id
+        it "should also remove the page from clipboard" do
+          xhr :post, :destroy, {id: page.id, _method: :delete}
+          expect(clipboard['pages']).to be_empty
         end
       end
-    end
 
-    describe '#destroy' do
-      let(:clipboard) { session[:alchemy_clipboard] = {} }
-      let(:page) { FactoryGirl.create(:public_page) }
+      describe '#publish' do
+        let(:page) { stub_model(Page, published_at: nil, public: false, name: "page", parent_id: 1, urlname: "page", language: stub_model(Language), page_layout: "bla") }
 
-      before { clipboard['pages'] = [{'id' => page.id.to_s}] }
-
-      it "should also remove the page from clipboard" do
-        xhr :post, :destroy, {id: page.id, _method: :delete}
-        expect(clipboard['pages']).to be_empty
-      end
-    end
-
-    describe '#publish' do
-      let(:page) { stub_model(Page, published_at: nil, public: false, name: "page", parent_id: 1, urlname: "page", language: stub_model(Language), page_layout: "bla") }
-
-      before do
-        allow(@controller).to receive(:load_page).and_return(page)
-        @controller.instance_variable_set("@page", page)
-      end
+        before do
+          allow(@controller).to receive(:load_page).and_return(page)
+          @controller.instance_variable_set("@page", page)
+        end
 
-      it "should publish the page" do
-        expect(page).to receive(:publish!)
-        post :publish, { id: page.id }
+        it "should publish the page" do
+          expect(page).to receive(:publish!)
+          post :publish, { id: page.id }
+        end
       end
-    end
 
-    describe '#visit' do
-      let(:page) { mock_model(Alchemy::Page, urlname: 'home') }
+      describe '#visit' do
+        let(:page) { mock_model(Alchemy::Page, urlname: 'home') }
 
-      before do
-        allow(Page).to receive(:find).with("#{page.id}").and_return(page)
-        allow(page).to receive(:unlock!).and_return(true)
-        allow(@controller).to receive(:multi_language?).and_return(false)
-      end
+        before do
+          allow(Page).to receive(:find).with("#{page.id}").and_return(page)
+          allow(page).to receive(:unlock!).and_return(true)
+          allow(@controller).to receive(:multi_language?).and_return(false)
+        end
 
-      it "should redirect to the page path" do
-        expect(post :visit, id: page.id).to redirect_to(show_page_path(urlname: 'home'))
+        it "should redirect to the page path" do
+          expect(post :visit, id: page.id).to redirect_to(show_page_path(urlname: 'home'))
+        end
       end
-    end
 
-    describe '#fold' do
-      let(:page) { mock_model(Alchemy::Page) }
-      before { allow(Page).to receive(:find).and_return(page) }
+      describe '#fold' do
+        let(:page) { mock_model(Alchemy::Page) }
+        before { allow(Page).to receive(:find).and_return(page) }
 
-      context "if page is currently not folded" do
-        before { allow(page).to receive(:folded?).and_return(false) }
+        context "if page is currently not folded" do
+          before { allow(page).to receive(:folded?).and_return(false) }
 
-        it "should fold the page" do
-          expect(page).to receive(:fold!).with(user.id, true).and_return(true)
-          xhr :post, :fold, id: page.id
+          it "should fold the page" do
+            expect(page).to receive(:fold!).with(user.id, true).and_return(true)
+            xhr :post, :fold, id: page.id
+          end
         end
-      end
 
-      context "if page is already folded" do
-        before { allow(page).to receive(:folded?).and_return(true) }
+        context "if page is already folded" do
+          before { allow(page).to receive(:folded?).and_return(true) }
 
-        it "should unfold the page" do
-          expect(page).to receive(:fold!).with(user.id, false).and_return(true)
-          xhr :post, :fold, id: page.id
+          it "should unfold the page" do
+            expect(page).to receive(:fold!).with(user.id, false).and_return(true)
+            xhr :post, :fold, id: page.id
+          end
         end
       end
-    end
 
-    describe '#sort' do
-      before { allow(Page).to receive(:language_root_for).and_return(mock_model(Alchemy::Page)) }
+      describe '#sort' do
+        before { allow(Page).to receive(:language_root_for).and_return(mock_model(Alchemy::Page)) }
 
-      it "should assign @sorting with true" do
-        xhr :get, :sort
-        expect(assigns(:sorting)).to eq(true)
+        it "should assign @sorting with true" do
+          xhr :get, :sort
+          expect(assigns(:sorting)).to eq(true)
+        end
       end
-    end
-
-    describe '#unlock' do
-      let(:page) { mock_model(Alchemy::Page, name: 'Best practices') }
 
-      before do
-        allow(Page).to receive(:find).with("#{page.id}").and_return(page)
-        allow(Page).to receive(:from_current_site).and_return(double(all_locked_by: nil))
-        expect(page).to receive(:unlock!).and_return(true)
-      end
+      describe '#unlock' do
+        let(:page) { mock_model(Alchemy::Page, name: 'Best practices') }
 
-      it "should unlock the page" do
-        xhr :post, :unlock, id: "#{page.id}"
-      end
+        before do
+          allow(Page).to receive(:find).with("#{page.id}").and_return(page)
+          allow(Page).to receive(:from_current_site).and_return(double(all_locked_by: nil))
+          expect(page).to receive(:unlock!).and_return(true)
+        end
 
-      context 'requesting for html format' do
-        it "should redirect to admin_pages_path" do
-          expect(post :unlock, id: page.id).to redirect_to(admin_pages_path)
+        it "should unlock the page" do
+          xhr :post, :unlock, id: "#{page.id}"
         end
 
-        context 'if passing :redirect_to through params' do
-          it "should redirect to the given path" do
-            expect(post :unlock, id: page.id, redirect_to: 'this/path').to redirect_to('this/path')
+        context 'requesting for html format' do
+          it "should redirect to admin_pages_path" do
+            expect(post :unlock, id: page.id).to redirect_to(admin_pages_path)
+          end
+
+          context 'if passing :redirect_to through params' do
+            it "should redirect to the given path" do
+              expect(post :unlock, id: page.id, redirect_to: 'this/path').to redirect_to('this/path')
+            end
           end
         end
       end
-    end
 
-    describe "#switch_language" do
-      let(:language) { build_stubbed(:klingonian)}
+      describe "#switch_language" do
+        let(:language) { build_stubbed(:klingonian)}
 
-      before do
-        allow(Language).to receive(:find_by).and_return(language)
-      end
+        before do
+          allow(Language).to receive(:find_by).and_return(language)
+        end
 
-      it "should store the current language in session" do
-        get :switch_language, {language_id: language.id}
-        expect(session[:alchemy_language_id]).to eq(language.id)
-      end
+        it "should store the current language in session" do
+          get :switch_language, {language_id: language.id}
+          expect(session[:alchemy_language_id]).to eq(language.id)
+        end
 
-      it "should redirect to sitemap" do
-        expect(get :switch_language, {language_id: language.id}).to redirect_to(admin_pages_path)
-      end
+        it "should redirect to sitemap" do
+          expect(get :switch_language, {language_id: language.id}).to redirect_to(admin_pages_path)
+        end
 
-      context "coming from layoutpages" do
-        before {
-          allow(request).to receive(:referer).and_return('admin/layoutpages')
-        }
+        context "coming from layoutpages" do
+          before {
+            allow(request).to receive(:referer).and_return('admin/layoutpages')
+          }
 
-        it "should redirect to layoutpages" do
-          expect(get :switch_language, {language_id: language.id}).to redirect_to(admin_layoutpages_path)
+          it "should redirect to layoutpages" do
+            expect(get :switch_language, {language_id: language.id}).to redirect_to(admin_layoutpages_path)
+          end
         end
       end
     end
-
   end
 end