alchemy_cms 3.0.0.rc7 → 3.0.0.rc8

data/config/locales/simple_form.fr.yml

@@ -0,0 +1,26 @@
+fr:
+  simple_form:
+    "yes": 'oui'
+    "no": 'non'
+    required:
+      text: 'champ obligatoire'
+      mark: '*'
+      # You can uncomment the line below if you need to overwrite the whole required html.
+      # When using html, text and mark won't be used.
+      # html: '<abbr title="required">*</abbr>'
+    error_notification:
+      default_message: "Il ya des erreurs:"
+    # Labels and hints examples
+    # labels:
+    #   defaults:
+    #     password: 'Password'
+    #   user:
+    #     new:
+    #       email: 'E-mail to sign in.'
+    #     edit:
+    #       email: 'E-mail.'
+    # hints:
+    #   defaults:
+    #     username: 'User name to sign in.'
+    #     password: 'No special characters, please.'
+

data/lib/alchemy/engine.rb

@@ -6,7 +6,6 @@ require 'action_view/dependency_tracker'
 require 'active_model_serializers'
 require 'awesome_nested_set'
 require 'cancan'
-require 'coffee-rails'
 require 'compass-rails'
 require 'dragonfly'
 require 'jquery-rails'
@@ -47,6 +46,9 @@ require_relative './touching'
 require_relative './kaminari/scoped_pagination_url_helper'
 require_relative '../extensions/action_view'
 
+# Middleware
+require_relative './middleware/rescue_old_cookies'
+
 module Alchemy
   class Engine < Rails::Engine
     isolate_namespace Alchemy
@@ -66,6 +68,10 @@ module Alchemy
       ]
     end
 
+    initializer 'alchemy.middleware.rescue_old_cookies' do |app|
+      app.middleware.insert_before(ActionDispatch::Cookies, Alchemy::Middleware::RescueOldCookies)
+    end
+
     initializer 'alchemy.dependency_tracker' do |app|
       [:erb, :slim, :haml].each do |handler|
         ActionView::DependencyTracker.register_tracker(handler, CacheDigests::TemplateTracker)

data/lib/alchemy/i18n.rb

@@ -45,7 +45,13 @@ module Alchemy
     end
 
     def self.available_locales
-      translation_files.collect { |f| f.match(/.{2}\.yml$/).to_s.gsub(/\.yml/, '') }
+      @@available_locales ||= nil
+      @@available_locales || translation_files.collect { |f| f.match(/.{2}\.yml$/).to_s.gsub(/\.yml/, '').to_sym }
+    end
+
+    def self.available_locales=(locales)
+      @@available_locales = Array(locales).map { |locale| locale.to_sym }
+      @@available_locales = nil if @@available_locales.empty?
     end
 
     def self.translation_files

data/lib/alchemy/middleware/rescue_old_cookies.rb

@@ -0,0 +1,27 @@
+module Alchemy
+  module Middleware
+    class RescueOldCookies
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        begin
+          @app.call(env)
+        rescue NameError => error
+          if error.to_s =~ /uninitialized constant Alchemy::Clipboard/
+            message = "<h2>You have an old style Alchemy clipboard in your session!</h2>"
+            message += "<h3>Please remove your cookies and try again.</h3>"
+            Rails.logger.error(error)
+            return [
+              500, { "Content-Type" => "text/html" },
+              [message]
+            ]
+          else
+            raise error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/alchemy/permissions.rb

@@ -86,12 +86,12 @@ module Alchemy
 
         # Controller actions
         can [:info, :help],             :alchemy_admin_dashboard
+        can :manage,                    :alchemy_admin_clipboard
         can :index,                     :trash
         can :edit,                      :alchemy_admin_layoutpages
 
         # Resources
         can [:read, :download],         Alchemy::Attachment
-        can :manage,                    Alchemy::Clipboard
         can :manage,                    Alchemy::Content
         can :manage,                    Alchemy::Element
         can :manage,                    Alchemy::EssenceFile

data/lib/alchemy/version.rb

@@ -1,5 +1,5 @@
 module Alchemy
-  VERSION = "3.0.0.rc7"
+  VERSION = "3.0.0.rc8"
 
   def self.version
     VERSION

data/spec/controllers/admin/clipboard_controller_spec.rb

@@ -8,51 +8,48 @@ module Alchemy
 
     before do
       sign_in(admin_user)
-      session[:clipboard] = Clipboard.new
+      session[:alchemy_clipboard] = {}
       Element.stub(find: element)
     end
 
     describe "#insert" do
       it "should hold element ids" do
-        xhr :post, :insert, {remarkable_type: :elements, remarkable_id: element.id}
-        session[:clipboard][:elements].should == [{id: element.id, action: 'copy'}]
+        xhr :post, :insert, {remarkable_type: 'elements', remarkable_id: element.id}
+        session[:alchemy_clipboard]['elements'].should == [{'id' => element.id.to_s, 'action' => 'copy'}]
       end
 
       it "should not have the same element twice" do
-        session[:clipboard][:elements] = {id: element.id, action: 'copy'}
-        xhr :post, :insert, {remarkable_type: :elements, remarkable_id: element.id}
-        session[:clipboard][:elements].collect { |e| e[:id] }.should_not == [element.id, element.id]
+        session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s, 'action' => 'copy'}]
+        xhr :post, :insert, {remarkable_type: 'elements', remarkable_id: element.id}
+        session[:alchemy_clipboard]['elements'].collect { |e| e['id'] }.should_not == [element.id, element.id]
       end
     end
 
     describe "#delete" do
       it "should remove element ids from clipboard" do
-        session[:clipboard][:elements] = {id: element.id, action: 'copy'}
-        session[:clipboard][:elements] << {id: another_element.id, action: 'copy'}
-        xhr :delete, :remove, {remarkable_type: :elements, remarkable_id: another_element.id}
-        session[:clipboard][:elements].should == [{id: element.id, action: 'copy'}]
+        session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s, 'action' => 'copy'}]
+        session[:alchemy_clipboard]['elements'] << {'id' => another_element.id.to_s, 'action' => 'copy'}
+        xhr :delete, :remove, {remarkable_type: 'elements', remarkable_id: another_element.id}
+        session[:alchemy_clipboard]['elements'].should == [{'id' => element.id.to_s, 'action' => 'copy'}]
       end
     end
 
     describe "#clear" do
-
       context "with elements as remarkable_type" do
         it "should clear the elements clipboard" do
-          session[:clipboard][:elements] = {id: element.id}
-          xhr :delete, :clear, {remarkable_type: :elements}
-          session[:clipboard].should be_empty
+          session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s}]
+          xhr :delete, :clear, {remarkable_type: 'elements'}
+          session[:alchemy_clipboard]['elements'].should be_empty
         end
       end
 
       context "with pages as remarkable_type" do
         it "should clear the pages clipboard" do
-          session[:clipboard][:pages] = {id: public_page.id}
-          xhr :delete, :clear, {remarkable_type: :pages}
-          session[:clipboard].should be_empty
+          session[:alchemy_clipboard]['pages'] = [{'id' => public_page.id.to_s}]
+          xhr :delete, :clear, {remarkable_type: 'pages'}
+          session[:alchemy_clipboard]['pages'].should be_empty
         end
       end
-
     end
-
   end
 end

data/spec/controllers/admin/elements_controller_spec.rb

@@ -5,7 +5,7 @@ module Alchemy
     let(:alchemy_page)         { create(:page) }
     let(:element)              { create(:element, :page_id => alchemy_page.id) }
     let(:element_in_clipboard) { create(:element, :page_id => alchemy_page.id) }
-    let(:clipboard)            { session[:clipboard] = Clipboard.new }
+    let(:clipboard)            { session[:alchemy_clipboard] = {} }
 
     before { sign_in(author_user) }
 
@@ -80,9 +80,9 @@ module Alchemy
       end
 
       context "with elements in clipboard" do
-        let(:clipboard_items) { [{:id => element.id, :action => 'copy'}] }
+        let(:clipboard_items) { [{'id' => element.id.to_s, 'action' => 'copy'}] }
 
-        before { clipboard[:elements] = clipboard_items }
+        before { clipboard['elements'] = clipboard_items }
 
         it "should load all elements from clipboard" do
           Element.should_receive(:all_from_clipboard_for_page).and_return(clipboard_items)
@@ -96,28 +96,25 @@ module Alchemy
       describe 'insertion position' do
         before { element }
 
-        context 'with no insert_after passed' do
-          it "should insert the element at top of list" do
-            xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}}
-            alchemy_page.elements.count.should == 2
-            alchemy_page.elements.first.name.should == 'news'
-          end
+        it "should insert the element at bottom of list" do
+          xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}}
+          alchemy_page.elements.count.should == 2
+          alchemy_page.elements.last.name.should == 'news'
         end
 
-        context "with insert_after passed in the params" do
-          let(:element_before) { create(:element, name: 'headline', page: alchemy_page) }
-
+        context "on a page with a setting for insert_elements_at of top" do
           before do
-            alchemy_page.elements.delete_all
-            element_before
+            PageLayout.stub(:get).and_return({
+              'name' => 'news',
+              'elements' => ['news'],
+              'insert_elements_at' => 'top'
+            })
           end
 
-          it "should insert the new element after that element" do
-            xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}, insert_after: element_before.id}
+          it "should insert the element at top of list" do
+            xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}}
             alchemy_page.elements.count.should == 2
-            alchemy_page.elements.reload
-            alchemy_page.elements.first.name.should == 'headline'
-            alchemy_page.elements.last.name.should == 'news'
+            alchemy_page.elements.first.name.should == 'news'
           end
         end
       end
@@ -161,7 +158,7 @@ module Alchemy
                 'cells' => ['header']
               })
               Cell.stub(:definition_for).and_return({'name' => 'header', 'elements' => ['article']})
-              clipboard[:elements] = [{:id => element_in_clipboard.id}]
+              clipboard['elements'] = [{'id' => element_in_clipboard.id.to_s}]
             end
 
             context "and cell name in element name" do
@@ -202,7 +199,7 @@ module Alchemy
                 'cells' => ['news']
               })
               Cell.stub(:definition_for).and_return({'name' => 'news', 'elements' => ['news']})
-              clipboard[:elements] = [{:id => element_in_clipboard.id}]
+              clipboard['elements'] = [{'id' => element_in_clipboard.id.to_s}]
               cell.elements << element
             end
 
@@ -220,7 +217,7 @@ module Alchemy
         render_views
 
         before do
-          clipboard[:elements] = [{id: element_in_clipboard.id, action: 'cut'}]
+          clipboard['elements'] = [{'id' => element_in_clipboard.id.to_s, 'action' => 'cut'}]
         end
 
         it "should create an element from clipboard" do
@@ -232,7 +229,7 @@ module Alchemy
         context "and with cut as action parameter" do
           it "should also remove the element id from clipboard" do
             xhr :post, :create, {paste_from_clipboard: element_in_clipboard.id, element: {page_id: alchemy_page.id}}
-            session[:clipboard].contains?(:elements, element_in_clipboard.id).should_not be_true
+            session[:alchemy_clipboard]['elements'].detect { |item| item['id'] == element_in_clipboard.id.to_s }.should be_nil
           end
         end
       end

data/spec/controllers/admin/essence_pictures_controller_spec.rb

@@ -41,7 +41,7 @@ module Alchemy
         before do
           picture.image_file_width = 300
           picture.image_file_height = 250
-          essence.should_receive(:picture).and_return(picture)
+          essence.should_receive(:picture).any_number_of_times.and_return(picture)
         end
 
         context 'with no render_size present in essence' do
@@ -67,14 +67,30 @@ module Alchemy
         end
 
         context 'with render_size present in essence' do
-          before do
+          it "sets sizes from these values" do
             essence.stub(:render_size).and_return('30x25')
-          end
 
-          it "sets sizes from these values" do
             get :crop, id: 1
-            expect(assigns(:size_x)).to eq('30')
-            expect(assigns(:size_y)).to eq('25')
+            expect(assigns(:size_x)).to eq(30)
+            expect(assigns(:size_y)).to eq(25)
+          end
+
+          context 'when width or height is not fixed' do
+            it 'infers the height from the image file preserving the aspect ratio' do
+              essence.stub(:render_size).and_return('30')
+
+              get :crop, id: 1
+              expect(assigns(:size_x)).to eq(30)
+              expect(assigns(:size_y)).to eq(25)
+            end
+
+            it 'infers the height from the image file preserving the aspect ratio' do
+              essence.stub(:render_size).and_return('x25')
+
+              get :crop, id: 1
+              expect(assigns(:size_x)).to eq(30)
+              expect(assigns(:size_y)).to eq(25)
+            end
           end
         end
 

data/spec/controllers/admin/pages_controller_spec.rb

@@ -54,10 +54,10 @@ module Alchemy
 
     describe '#new' do
       context "pages in clipboard" do
-        let(:clipboard) { session[:clipboard] = Clipboard.new }
+        let(:clipboard) { session[:alchemy_clipboard] = {} }
         let(:page) { mock_model(Alchemy::Page, name: 'Foobar') }
 
-        before { clipboard[:pages] = [{id: page.id, action: 'copy'}] }
+        before { clipboard['pages'] = [{'id' => page.id.to_s, 'action' => 'copy'}] }
 
         it "should load all pages from clipboard" do
           xhr :get, :new, {page_id: page.id}
@@ -96,6 +96,95 @@ module Alchemy
       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
+
+      context 'with url nesting enabled' do
+        before { Alchemy::Config.stub(get: true) }
+
+        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_2.slug}/#{page_3.slug}")
+        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_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
+
+        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 "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
+
+        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_true
+          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
 
@@ -289,14 +378,14 @@ module Alchemy
     end
 
     describe '#destroy' do
-      let(:clipboard) { session[:clipboard] = Clipboard.new }
+      let(:clipboard) { session[:alchemy_clipboard] = {} }
       let(:page) { FactoryGirl.create(:public_page) }
 
-      before { clipboard[:pages] = [{id: page.id}] }
+      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}
-        clipboard[:pages].should be_empty
+        clipboard['pages'].should be_empty
       end
     end