alchemy_cms 3.0.4 → 3.1.0.beta1

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

@@ -32,7 +32,6 @@ module Alchemy
         template "page_layouts.yml.tt", "#{Rails.root}/config/alchemy/page_layouts.yml"
         copy_file "#{current_path}/files/alchemy.en.yml", "#{Rails.root}/config/locales/alchemy.en.yml"
         copy_file "#{current_path}/files/alchemy.de.yml", "#{Rails.root}/config/locales/alchemy.de.yml"
-        copy_file "#{current_path}/files/alchemy.es.yml", "#{Rails.root}/config/locales/alchemy.es.yml"
         copy_file "#{current_path}/files/application.html.erb", "#{Rails.root}/app/views/layouts/application.html.erb"
         copy_file "#{current_path}/files/_standard.html.erb", "#{Rails.root}/app/views/alchemy/page_layouts/_standard.html.erb"
         copy_file "#{current_path}/files/_article_view.html.erb", "#{Rails.root}/app/views/alchemy/elements/_article_view.html.erb"

data/lib/rails/templates/alchemy.rb

@@ -1,6 +1,6 @@
 # This rails template installs Alchemy and all depending gems.
 require File.expand_path('../../../alchemy/version', __FILE__)
 
-gem 'alchemy_cms', github: 'magiclabs/alchemy_cms', branch: '3.0-stable'
-gem 'alchemy-devise', github: 'magiclabs/alchemy-devise', branch: '2.0-stable'
+gem 'alchemy_cms', github: 'magiclabs/alchemy_cms', branch: 'master'
+gem 'alchemy-devise', github: 'magiclabs/alchemy-devise', branch: 'master'
 gem 'capistrano', '~> 2.15.5', group: 'development'

data/lib/tasks/alchemy/db.rake

@@ -1,10 +1,10 @@
+require 'shellwords'
 require 'alchemy/seeder'
 require 'alchemy/tasks/helpers'
 include Alchemy::Tasks::Helpers
 
 namespace :alchemy do
   namespace :db do
-
     desc "Seeds your database with essential data for Alchemy CMS."
     task :seed => :environment do
       Alchemy::Seeder.seed!
@@ -17,5 +17,11 @@ namespace :alchemy do
       system "#{dump_cmd}#{dump_store}"
     end
 
+    desc "Imports the database from STDIN (Pass DUMP_FILENAME to read the dump from file)."
+    task :import => :environment do
+      dump_store = ENV['DUMP_FILENAME'] ? "cat #{ENV['DUMP_FILENAME']}" : "echo #{Shellwords.escape(STDIN.read)}"
+      import_cmd = database_import_command(database_config['adapter'])
+      system "#{dump_store} | #{import_cmd}"
+    end
   end
 end

data/spec/controllers/admin/attachments_controller_spec.rb

@@ -10,13 +10,13 @@ module Alchemy
 
     describe "#index" do
       it "should always paginate the records" do
-        Attachment.should_receive(:find_paginated)
+        expect(Attachment).to receive(:find_paginated)
         get :index
       end
 
       context "when params[:tagged_with] is set" do
         it "should filter the records by tags" do
-          Attachment.should_receive(:tagged_with).and_return(Attachment.all)
+          expect(Attachment).to receive(:tagged_with).and_return(Attachment.all)
           get :index, tagged_with: "pdf"
         end
       end
@@ -26,10 +26,10 @@ module Alchemy
 
         context "is set" do
           it "it renders the archive_overlay partial" do
-            Content.stub_chain(:select, :find_by).and_return(content)
+            expect(Content).to receive(:find_by).and_return(content)
             get :index, {content_id: content.id}
             expect(response).to render_template(partial: '_archive_overlay')
-            assigns(:content).should eq(content)
+            expect(assigns(:content)).to eq(content)
           end
         end
 
@@ -44,7 +44,7 @@ module Alchemy
 
     describe '#show' do
       before do
-        Attachment.stub(find: attachment)
+        expect(Attachment).to receive(:find).and_return(attachment)
       end
 
       it "renders the show template" do
@@ -56,18 +56,18 @@ module Alchemy
     describe "#new" do
       context "in overlay" do
         before do
-          controller.stub(:in_overlay?).and_return(true)
-          Content.stub(:find).and_return(mock_model('Content'))
+          expect(controller).to receive(:in_overlay?).and_return(true)
+          expect(Content).to receive(:find_by).and_return(mock_model('Content'))
         end
 
         it "should set @while_assigning to true" do
           get :new
-          assigns(:while_assigning).should eq(true)
+          expect(assigns(:while_assigning)).to eq(true)
         end
 
         it "should set @swap to params[:swap]" do
           get :new, swap: 'true'
-          assigns(:swap).should eq('true')
+          expect(assigns(:swap)).to eq('true')
         end
       end
     end
@@ -80,8 +80,8 @@ module Alchemy
 
       context 'with passing validations' do
         before do
-          Attachment.should_receive(:new).and_return(attachment)
-          attachment.should_receive(:save).and_return(true)
+          expect(Attachment).to receive(:new).and_return(attachment)
+          expect(attachment).to receive(:save).and_return(true)
         end
 
         context 'if inside of archive overlay' do
@@ -89,36 +89,36 @@ module Alchemy
           let(:content) { mock_model('Content') }
 
           before do
-            Content.stub_chain(:select, :find_by).and_return(content)
+            expect(Content).to receive(:find_by).and_return(content)
           end
 
           it "assigns lots of instance variables" do
             subject
-            assigns(:options).should eq({})
-            assigns(:while_assigning).should be_true
-            assigns(:content).should eq(content)
-            assigns(:swap).should eq(nil)
+            expect(assigns(:options)).to eq({})
+            expect(assigns(:while_assigning)).to be_truthy
+            expect(assigns(:content)).to eq(content)
+            expect(assigns(:swap)).to eq(nil)
           end
         end
 
         it "renders json response with success message" do
           subject
-          response.content_type.should eq('application/json')
-          response.status.should eq(201)
+          expect(response.content_type).to eq('application/json')
+          expect(response.status).to eq(201)
           json = JSON.parse(response.body)
-          json.should have_key('growl_message')
-          json.should have_key('files')
+          expect(json).to have_key('growl_message')
+          expect(json).to have_key('files')
         end
       end
 
       context 'without passing validations' do
         it "renders json response with error message" do
           subject
-          response.content_type.should eq('application/json')
-          response.status.should eq(422)
+          expect(response.content_type).to eq('application/json')
+          expect(response.status).to eq(422)
           json = JSON.parse(response.body)
-          json.should have_key('growl_message')
-          json.should have_key('files')
+          expect(json).to have_key('growl_message')
+          expect(json).to have_key('files')
         end
       end
     end
@@ -129,27 +129,27 @@ module Alchemy
       let(:attachment) { build_stubbed(:attachment) }
 
       before do
-        Attachment.stub(find: attachment)
+        expect(Attachment).to receive(:find).and_return(attachment)
       end
 
       context 'with passing validations' do
         before do
-          attachment.should_receive(:update_attributes).and_return(true)
+          expect(attachment).to receive(:update_attributes).and_return(true)
         end
 
         it "redirects to index path" do
-          should redirect_to admin_attachments_path
+          is_expected.to redirect_to admin_attachments_path
         end
       end
 
       context 'with failing validations' do
         before do
-          attachment.stub(update_attributes: false)
-          attachment.stub_chain(:errors, :empty?).and_return(false)
+          expect(attachment).to receive(:update_attributes).and_return(false)
+          expect(attachment).to receive(:errors).and_return double(empty?: false)
         end
 
         it "renders edit form" do
-          should render_template(:edit)
+          is_expected.to render_template(:edit)
         end
       end
     end
@@ -158,22 +158,22 @@ module Alchemy
       let(:attachment) { build_stubbed(:attachment) }
 
       before do
-        Attachment.stub(find: attachment)
+        expect(Attachment).to receive(:find).and_return(attachment)
       end
 
       it "destroys the attachment and sets and success message" do
-        attachment.should_receive(:destroy)
+        expect(attachment).to receive(:destroy)
         xhr :delete, :destroy
-        assigns(:attachment).should eq(attachment)
-        assigns(:url).should_not be_blank
-        flash[:notice].should_not be_blank
+        expect(assigns(:attachment)).to eq(attachment)
+        expect(assigns(:url)).not_to be_blank
+        expect(flash[:notice]).not_to be_blank
       end
     end
 
     describe "#download" do
       before do
-        Attachment.stub(:find).with("#{attachment.id}").and_return(attachment)
-        controller.stub(:render).and_return(nil)
+        expect(Attachment).to receive(:find).with("#{attachment.id}").and_return(attachment)
+        allow(controller).to receive(:render).and_return(nil)
       end
 
       it "should assign @attachment with Attachment found by id" do
@@ -182,7 +182,7 @@ module Alchemy
       end
 
       it "should send the data to the browser" do
-        controller.should_receive(:send_data)
+        expect(controller).to receive(:send_data)
         get :download, id: attachment.id
       end
     end

data/spec/controllers/admin/base_controller_spec.rb

@@ -6,7 +6,7 @@ describe Alchemy::Admin::BaseController do
     subject { controller.send(:options_from_params) }
 
     context "params[:options] is a JSON string" do
-      before { controller.stub(:params).and_return(options: '{"hallo":"World"}') }
+      before { expect(controller).to receive(:params).at_least(:once).and_return(options: '{"hallo":"World"}') }
 
       it "parses the string into an object" do
         expect(subject).to be_an_instance_of(Hash)
@@ -15,7 +15,7 @@ describe Alchemy::Admin::BaseController do
     end
 
     context "params[:options] is already an object" do
-      before { controller.stub(:params).and_return(options: {hallo: "World"}) }
+      before { expect(controller).to receive(:params).at_least(:once).and_return(options: {hallo: "World"}) }
 
       it "parses the string into an object" do
         expect(subject).to be_an_instance_of(Hash)
@@ -23,7 +23,7 @@ describe Alchemy::Admin::BaseController do
     end
 
     context "params[:options] is not present" do
-      before { controller.stub(:params).and_return({}) }
+      before { expect(controller).to receive(:params).at_least(:once).and_return({}) }
 
       it "returns ampty object" do
         expect(subject).to be_an_instance_of(Hash)
@@ -36,22 +36,22 @@ describe Alchemy::Admin::BaseController do
     subject { controller.send(:raise_exception?) }
 
     context 'in test mode' do
-      before { Rails.env.stub(test?: true) }
-      it { should be_true }
-    end
-
-    context 'in page preview' do
-      before { controller.stub(is_page_preview?: true) }
-      it { should be_true }
+      before { expect(Rails.env).to receive(:test?).and_return true }
+      it { is_expected.to be_truthy }
     end
 
     context 'not in test mode' do
-      before { Rails.env.stub(test?: false) }
-      it { should be_false }
+      before { expect(Rails.env).to receive(:test?).and_return false }
+      it { is_expected.to be_falsey }
+
+      context 'and in page preview' do
+        before { expect(controller).to receive(:is_page_preview?).and_return true }
+        it { is_expected.to be_truthy }
+      end
 
       context 'and not in page preview' do
-        before { controller.stub(is_page_preview?: false) }
-        it { should be_false }
+        before { expect(controller).to receive(:is_page_preview?).and_return false }
+        it { is_expected.to be_falsey }
       end
     end
   end
@@ -59,15 +59,15 @@ describe Alchemy::Admin::BaseController do
   describe '#is_page_preview?' do
     subject { controller.send(:is_page_preview?) }
 
-    it { should be_false }
+    it { is_expected.to be_falsey }
 
     context 'is pages controller and show action' do
       before do
-        controller.stub(controller_path: 'alchemy/admin/pages')
-        controller.stub(action_name: 'show')
+        expect(controller).to receive(:controller_path).and_return('alchemy/admin/pages')
+        expect(controller).to receive(:action_name).and_return('show')
       end
 
-      it { should be_true }
+      it { is_expected.to be_truthy }
     end
   end
 

data/spec/controllers/admin/clipboard_controller_spec.rb

@@ -9,28 +9,33 @@ module Alchemy
     before do
       sign_in(admin_user)
       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[:alchemy_clipboard]['elements'].should == [{'id' => element.id.to_s, 'action' => 'copy'}]
+    context 'for elements' do
+      before do
+        expect(Element).to receive(:find).and_return(element)
       end
 
-      it "should not have the same element twice" do
-        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]
+      describe "#insert" do
+        it "should hold element ids" do
+          xhr :post, :insert, {remarkable_type: 'elements', remarkable_id: element.id}
+          expect(session[:alchemy_clipboard]['elements']).to eq([{'id' => element.id.to_s, 'action' => 'copy'}])
+        end
+
+        it "should not have the same element twice" do
+          session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s, 'action' => 'copy'}]
+          xhr :post, :insert, {remarkable_type: 'elements', remarkable_id: element.id}
+          expect(session[:alchemy_clipboard]['elements'].collect { |e| e['id'] }).not_to eq([element.id, element.id])
+        end
       end
-    end
 
-    describe "#delete" do
-      it "should remove element ids from clipboard" do
-        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'}]
+      describe "#delete" do
+        it "should remove element ids from clipboard" do
+          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}
+          expect(session[:alchemy_clipboard]['elements']).to eq([{'id' => element.id.to_s, 'action' => 'copy'}])
+        end
       end
     end
 
@@ -39,7 +44,7 @@ module Alchemy
         it "should clear the elements clipboard" do
           session[:alchemy_clipboard]['elements'] = [{'id' => element.id.to_s}]
           xhr :delete, :clear, {remarkable_type: 'elements'}
-          session[:alchemy_clipboard]['elements'].should be_empty
+          expect(session[:alchemy_clipboard]['elements']).to be_empty
         end
       end
 
@@ -47,7 +52,7 @@ module Alchemy
         it "should clear the pages clipboard" do
           session[:alchemy_clipboard]['pages'] = [{'id' => public_page.id.to_s}]
           xhr :delete, :clear, {remarkable_type: 'pages'}
-          session[:alchemy_clipboard]['pages'].should be_empty
+          expect(session[:alchemy_clipboard]['pages']).to be_empty
         end
       end
     end

data/spec/controllers/admin/contents_controller_spec.rb

@@ -7,48 +7,54 @@ module Alchemy
 
     before do
       sign_in(admin_user)
-      Element.stub(find: element)
     end
 
-    describe '#create' do
-      let(:element) { build_stubbed(:element, name: 'headline') }
-
-      it "creates a content from name" do
-        Content.should_receive(:create_from_scratch).and_return(content)
-        xhr :post, :create, {content: {element_id: element.id, name: 'headline'}}
+    context 'with element_id parameter' do
+      before do
+        expect(Element).to receive(:find).and_return(element)
       end
 
-      it "creates a content from essence_type" do
-        Content.should_receive(:create_from_scratch).and_return(content)
-        xhr :post, :create, {content: {element_id: element.id, essence_type: 'EssencePicture'}}
-      end
-    end
 
-    context 'inside a picture gallery' do
-      let(:attributes) do
-        {content: {element_id: element.id, essence_type: 'Alchemy::EssencePicture'}, options: {grouped: 'true'}}
-      end
+      describe '#create' do
+        let(:element) { build_stubbed(:element, name: 'headline') }
+
+        it "creates a content from name" do
+          expect(Content).to receive(:create_from_scratch).and_return(content)
+          xhr :post, :create, {content: {element_id: element.id, name: 'headline'}}
+        end
 
-      it "adds it into the gallery editor" do
-        xhr :post, :create, attributes
-        assigns(:content_dom_id).should eq("#add_picture_#{element.id}")
+        it "creates a content from essence_type" do
+          expect(Content).to receive(:create_from_scratch).and_return(content)
+          xhr :post, :create, {content: {element_id: element.id, essence_type: 'EssencePicture'}}
+        end
       end
 
-      context 'with picture_id given' do
-        it "assigns the picture" do
-          Content.any_instance.should_receive(:update_essence).with(picture_id: '1')
-          xhr :post, :create, attributes.merge(picture_id: '1')
+      context 'inside a picture gallery' do
+        let(:attributes) do
+          {content: {element_id: element.id, essence_type: 'Alchemy::EssencePicture'}, options: {grouped: 'true'}}
+        end
+
+        it "adds it into the gallery editor" do
+          xhr :post, :create, attributes
+          expect(assigns(:content_dom_id)).to eq("#add_picture_#{element.id}")
+        end
+
+        context 'with picture_id given' do
+          it "assigns the picture" do
+            expect_any_instance_of(Content).to receive(:update_essence).with(picture_id: '1')
+            xhr :post, :create, attributes.merge(picture_id: '1')
+          end
         end
       end
     end
 
     describe '#update' do
       before do
-        Content.stub(find: content)
+        expect(Content).to receive(:find).and_return(content)
       end
 
       it "should update a content via ajax" do
-        content.essence.should_receive(:update).with('ingredient' => 'Peters Petshop')
+        expect(content.essence).to receive(:update).with('ingredient' => 'Peters Petshop')
         xhr :post, :update, {id: content.id, content: {ingredient: 'Peters Petshop'}}
       end
     end
@@ -58,8 +64,8 @@ module Alchemy
         it "should reorder the contents" do
           content_ids = element.contents.essence_texts.pluck(:id)
           xhr :post, :order, {content_ids: content_ids.reverse}
-          response.status.should == 200
-          element.contents.essence_texts.pluck(:id).should == content_ids.reverse
+          expect(response.status).to eq(200)
+          expect(element.contents.essence_texts.pluck(:id)).to eq(content_ids.reverse)
         end
       end
     end