alchemy_cms 3.2.0.rc1 → 3.2.0

data/lib/alchemy/auth_accessors.rb

@@ -66,7 +66,7 @@ module Alchemy
       if @@user_class_name.is_a?(String)
         @@user_class_name.constantize
       else
-        raise 'Alchemy.user_class_name must be a String, not a Class.'
+        raise TypeError, 'Alchemy.user_class_name must be a String, not a Class.'
       end
     end
   rescue NameError => e

data/lib/alchemy/config.rb

@@ -15,12 +15,12 @@ module Alchemy
       alias_method :parameter, :get
 
       # Returns a merged configuration of the following files
-      # 
+      #
       # Alchemy´s default config: +gems/../alchemy_cms/config/alchemy/config.yml+
       # Your apps default config: +your_app/config/alchemy/config.yml+
       # Environment specific config: +your_app/config/alchemy/development.config.yml+
       #
-      # An environment specific config overwrites the settings of your apps default config, 
+      # An environment specific config overwrites the settings of your apps default config,
       # while your apps default config has precedence over Alchemy´s default config.
       #
       def show
@@ -53,15 +53,13 @@ module Alchemy
       end
 
       # Merges all given configs together
-      # 
+      #
       def merge_configs!(*config_files)
         raise LoadError, 'No Alchemy config file found!' if config_files.map(&:blank?).all?
         config = {}
         config_files.each {|h| config.merge!(h.stringify_keys!) }
         config
       end
-
     end
-
   end
 end

data/lib/alchemy/errors.rb

@@ -17,6 +17,13 @@ module Alchemy
     end
   end
 
+  class DefaultLanguageNotDeletable < StandardError
+    # Raised if one tries to delete the default language.
+    def message
+      "Default language is not deletable!"
+    end
+  end
+
   class ElementDefinitionError < StandardError
     # Raised if element definition can not be found.
     def initialize(attributes)
@@ -39,6 +46,13 @@ module Alchemy
     # Raised if calling +image_file+ on a Picture object returns nil.
   end
 
+  class NotMountedError < StandardError
+    # Raised if Alchemy is not properly mounted in the apps routes file.
+    def message
+      "Alchemy mount point not found! Please run `bin/rake alchemy:mount'"
+    end
+  end
+
   class PictureInUseError < StandardError
     # Raised if the picture is still in use and can not be deleted.
   end

data/lib/alchemy/modules.rb

@@ -39,7 +39,7 @@ module Alchemy
           definition_from_subnavi(alchemy_module, name.symbolize_keys)
         end
       else
-        raise "Could not find module definition for #{name}"
+        raise ArgumentError, "Could not find module definition for #{name}"
       end
     end
 

data/lib/alchemy/mount_point.rb

@@ -27,7 +27,7 @@ module Alchemy
       def path
         match = File.read(routes_file_path).match(MOUNT_POINT_REGEXP)
         if match.nil?
-          raise "Alchemy mount point not found! Please run `bin/rake alchemy:mount'"
+          raise NotMountedError
         else
           match[1]
         end

data/lib/alchemy/tasks/helpers.rb

@@ -13,7 +13,7 @@ module Alchemy
       def database_config
         raise "Could not find #{database_config_file}!" if !File.exists?(database_config_file)
         @database_config ||= begin
-          config_file = YAML.load_file(database_config_file)
+          config_file = YAML.load(ERB.new(File.read(database_config_file)).result)
           config_file.fetch(environment)
           rescue KeyError
             raise "Database configuration for #{environment} not found!"

data/lib/alchemy/version.rb

@@ -1,5 +1,5 @@
 module Alchemy
-  VERSION = "3.2.0.rc1"
+  VERSION = "3.2.0"
 
   def self.version
     VERSION

data/lib/rails/generators/alchemy/base.rb

@@ -32,7 +32,7 @@ module Alchemy
       end
 
       def load_alchemy_yaml(name)
-        YAML.load_file "#{Rails.root}/config/alchemy/#{name}"
+        YAML.load(ERB.new(File.read("#{Rails.root}/config/alchemy/#{name}")).result)
       rescue Errno::ENOENT
         puts "\nERROR: Could not read config/alchemy/#{name} file. Please run: rails generate alchemy:scaffold"
       end

data/lib/rails/templates/alchemy.rb

@@ -2,6 +2,6 @@
 require File.expand_path("../../../alchemy/version", __FILE__)
 
 gem "alchemy_cms",    github: "AlchemyCMS/alchemy_cms",    branch: "3.2-stable"
-gem "alchemy-devise", github: "AlchemyCMS/alchemy-devise", branch: "master"
+gem "alchemy-devise", github: "AlchemyCMS/alchemy-devise", branch: "3.2-stable"
 
 gem "capistrano-alchemy", github: "AlchemyCMS/capistrano-alchemy", branch: "master", group: "development"

data/spec/controllers/admin/elements_controller_spec.rb

@@ -89,7 +89,7 @@ module Alchemy
 
         it "sets a list of trashed element ids" do
           alchemy_xhr :post, :order, element_ids: [trashed_element.id]
-          expect(assigns(:trashed_elements).to_a).to eq [trashed_element.id]
+          expect(assigns(:trashed_element_ids).to_a).to eq [trashed_element.id]
         end
 
         it "sets a new position to the element" do

data/spec/controllers/alchemy/api/contents_controller_spec.rb

@@ -2,22 +2,6 @@ require 'spec_helper'
 
 module Alchemy
   describe Api::ContentsController do
-    # We need to be sure, that the timestamps are always the same,
-    # while comparing json objects
-    before do
-      allow_any_instance_of(Alchemy::Content).
-        to receive(:created_at).and_return(Time.now)
-      allow_any_instance_of(Alchemy::Content).
-        to receive(:updated_at).and_return(Time.now)
-      allow_any_instance_of(Alchemy::EssenceText).
-        to receive(:created_at).and_return(Time.now)
-      allow_any_instance_of(Alchemy::EssenceText).
-        to receive(:updated_at).and_return(Time.now)
-      allow_any_instance_of(Alchemy::EssenceRichtext).
-        to receive(:created_at).and_return(Time.now)
-      allow_any_instance_of(Alchemy::EssenceRichtext).
-        to receive(:updated_at).and_return(Time.now)
-    end
 
     describe '#index' do
       let!(:page)    { create(:page) }
@@ -26,9 +10,14 @@ module Alchemy
 
       it "returns all public contents as json objects" do
         alchemy_get :index, format: :json
+
         expect(response.status).to eq(200)
         expect(response.content_type).to eq('application/json')
-        expect(response.body).to eq("{\"contents\":[#{ContentSerializer.new(content).to_json}]}")
+
+        result = JSON.parse(response.body)
+
+        expect(result).to have_key("contents")
+        expect(result['contents'].size).to eq(Alchemy::Content.count)
       end
 
       context 'with element_id' do
@@ -37,18 +26,29 @@ module Alchemy
 
         it "returns only contents from this element" do
           alchemy_get :index, element_id: other_element.id, format: :json
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq("{\"contents\":[#{ContentSerializer.new(other_content).to_json}]}")
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key("contents")
+          expect(result['contents'].size).to eq(1)
+          expect(result['contents'][0]['element_id']).to eq(other_element.id)
         end
       end
 
       context 'with empty element_id' do
         it "returns all contents" do
           alchemy_get :index, element_id: element.id, format: :json
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq("{\"contents\":[#{ContentSerializer.new(content).to_json}]}")
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key("contents")
+          expect(result['contents'].size).to eq(Alchemy::Content.count)
         end
       end
     end
@@ -65,9 +65,13 @@ module Alchemy
 
         it "returns content as json" do
           alchemy_get :show, id: content.id, format: :json
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq(ContentSerializer.new(content).to_json)
+
+          result = JSON.parse(response.body)
+
+          expect(result['id']).to eq(content.id)
         end
 
         context 'requesting an restricted content' do
@@ -75,9 +79,14 @@ module Alchemy
 
           it "responds with 403" do
             alchemy_get :show, id: content.id, format: :json
+
             expect(response.content_type).to eq('application/json')
             expect(response.status).to eq(403)
-            expect(response.body).to eq('{"error":"Not authorized"}')
+
+            result = JSON.parse(response.body)
+
+            expect(result).to have_key("error")
+            expect(result['error']).to eq("Not authorized")
           end
         end
       end
@@ -89,18 +98,27 @@ module Alchemy
 
         it 'returns the named content from element with given id.' do
           alchemy_get :show, element_id: element.id, name: content.name, format: :json
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq(ContentSerializer.new(content).to_json)
+
+          result = JSON.parse(response.body)
+
+          expect(result['id']).to eq(content.id)
         end
       end
 
       context 'with empty element_id or name param' do
         it 'returns 404 error.' do
           alchemy_get :show, element_id: '', name: '', format: :json
+
           expect(response.status).to eq(404)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq("{\"error\":\"Record not found\"}")
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key("error")
+          expect(result['error']).to eq("Record not found")
         end
       end
     end

data/spec/controllers/alchemy/api/elements_controller_spec.rb

@@ -2,25 +2,24 @@ require 'spec_helper'
 
 module Alchemy
   describe Api::ElementsController do
-    # We need to be sure, that the timestamps are always the same,
-    # while comparing json objects
-    before do
-      allow_any_instance_of(Alchemy::Element).
-        to receive(:created_at).and_return(Time.now)
-      allow_any_instance_of(Alchemy::Element).
-        to receive(:updated_at).and_return(Time.now)
-    end
 
     describe '#index' do
-      let!(:page)    { create(:public_page) }
-      let!(:element) { create(:element, page: page) }
+      let(:page) { create(:public_page) }
+
+      before do
+        2.times { create(:element, page: page) }
+      end
 
       it "returns all public elements as json objects" do
         alchemy_get :index, format: :json
+
         expect(response.status).to eq(200)
         expect(response.content_type).to eq('application/json')
-        expect(response.body).to_not eq('{"elements:[]"}')
-        expect(response.body).to eq("{\"elements\":[#{ElementSerializer.new(element).to_json}]}")
+
+        result = JSON.parse(response.body)
+
+        expect(result).to have_key('elements')
+        expect(result['elements'].size).to eq(Alchemy::Element.count)
       end
 
       context 'with page_id param' do
@@ -29,19 +28,29 @@ module Alchemy
 
         it "returns only elements from this page" do
           alchemy_get :index, page_id: other_page.id, format: :json
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq("{\"elements\":[#{ElementSerializer.new(other_element).to_json}]}")
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key('elements')
+          expect(result['elements'].size).to eq(1)
+          expect(result['elements'][0]['page_id']).to eq(other_page.id)
         end
       end
 
       context 'with empty page_id param' do
         it "returns all elements" do
           alchemy_get :index, page_id: '', format: :json
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to_not eq('{"elements:[]"}')
-          expect(response.body).to eq("{\"elements\":[#{ElementSerializer.new(element).to_json}]}")
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key('elements')
+          expect(result['elements'].size).to eq(Alchemy::Element.count)
         end
       end
 
@@ -50,19 +59,29 @@ module Alchemy
 
         it "returns only elements named like this." do
           alchemy_get :index, named: 'news', format: :json
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq("{\"elements\":[#{ElementSerializer.new(other_element).to_json}]}")
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key('elements')
+          expect(result['elements'].size).to eq(1)
+          expect(result['elements'][0]['name']).to eq('news')
         end
       end
 
       context 'with empty named param' do
         it "returns all elements" do
           alchemy_get :index, named: '', format: :json
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to_not eq('{"elements:[]"}')
-          expect(response.body).to eq("{\"elements\":[#{ElementSerializer.new(element).to_json}]}")
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key('elements')
+          expect(result['elements'].size).to eq(Alchemy::Element.count)
         end
       end
     end
@@ -77,9 +96,13 @@ module Alchemy
 
       it "returns element as json" do
         alchemy_get :show, id: element.id, format: :json
+
         expect(response.status).to eq(200)
         expect(response.content_type).to eq('application/json')
-        expect(response.body).to eq(ElementSerializer.new(element).to_json)
+
+        result = JSON.parse(response.body)
+
+        expect(result['id']).to eq(element.id)
       end
 
       context 'requesting an restricted element' do
@@ -87,9 +110,14 @@ module Alchemy
 
         it "responds with 403" do
           alchemy_get :show, id: element.id, format: :json
-          expect(response.content_type).to eq('application/json')
+
           expect(response.status).to eq(403)
-          expect(response.body).to eq('{"error":"Not authorized"}')
+          expect(response.content_type).to eq('application/json')
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key('error')
+          expect(result['error']).to eq("Not authorized")
         end
       end
     end

data/spec/controllers/alchemy/api/pages_controller_spec.rb

@@ -8,28 +8,43 @@ module Alchemy
 
       it "returns all public pages as json objects" do
         alchemy_get :index, format: :json
+
         expect(response.status).to eq(200)
         expect(response.content_type).to eq('application/json')
-        expect(response.body).to eq("{\"pages\":[#{PageSerializer.new(page.parent).to_json},#{PageSerializer.new(page).to_json}]}")
+
+        result = JSON.parse(response.body)
+
+        expect(result).to have_key('pages')
+        expect(result['pages'].size).to eq(2)
       end
 
       context 'with page_layout' do
         let!(:other_page) { create(:public_page, page_layout: 'news') }
 
-        it "returns only pages with this page layout" do
+        it "returns only page with this page layout" do
           alchemy_get :index, {page_layout: 'news', format: :json}
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq("{\"pages\":[#{PageSerializer.new(other_page).to_json}]}")
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key('pages')
+          expect(result['pages'].size).to eq(1)
         end
       end
 
       context 'with empty string as page_layout' do
         it "returns all pages" do
           alchemy_get :index, {page_layout: '', format: :json}
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq("{\"pages\":[#{PageSerializer.new(page.parent).to_json},#{PageSerializer.new(page).to_json}]}")
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key('pages')
+          expect(result['pages'].size).to eq(2)
         end
       end
     end
@@ -44,9 +59,13 @@ module Alchemy
 
         it "returns page as json" do
           alchemy_get :show, {urlname: page.urlname, format: :json}
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq(PageSerializer.new(page).to_json)
+
+          result = JSON.parse(response.body)
+
+          expect(result['id']).to eq(page.id)
         end
 
         context 'requesting an restricted page' do
@@ -54,9 +73,14 @@ module Alchemy
 
           it "responds with 403" do
             alchemy_get :show, {urlname: page.urlname, format: :json}
-            expect(response.content_type).to eq('application/json')
+
             expect(response.status).to eq(403)
-            expect(response.body).to eq('{"error":"Not authorized"}')
+            expect(response.content_type).to eq('application/json')
+
+            result = JSON.parse(response.body)
+
+            expect(result).to have_key('error')
+            expect(result['error']).to eq("Not authorized")
           end
         end
 
@@ -65,9 +89,14 @@ module Alchemy
 
           it "responds with 403" do
             alchemy_get :show, {urlname: page.urlname, format: :json}
-            expect(response.content_type).to eq('application/json')
+
             expect(response.status).to eq(403)
-            expect(response.body).to eq('{"error":"Not authorized"}')
+            expect(response.content_type).to eq('application/json')
+
+            result = JSON.parse(response.body)
+
+            expect(result).to have_key('error')
+            expect(result['error']).to eq("Not authorized")
           end
         end
       end
@@ -75,9 +104,14 @@ module Alchemy
       context 'requesting an unknown page' do
         it "responds with 404" do
           alchemy_get :show, {urlname: 'not-existing', format: :json}
-          expect(response.content_type).to eq('application/json')
+
           expect(response.status).to eq(404)
-          expect(response.body).to eq('{"error":"Record not found"}')
+          expect(response.content_type).to eq('application/json')
+
+          result = JSON.parse(response.body)
+
+          expect(result).to have_key('error')
+          expect(result['error']).to eq("Record not found")
         end
       end
 
@@ -86,9 +120,13 @@ module Alchemy
 
         it "responds with json" do
           alchemy_get :show, {id: page.id, format: :json}
+
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to eq(PageSerializer.new(page).to_json)
+
+          result = JSON.parse(response.body)
+
+          expect(result['id']).to eq(page.id)
         end
       end
     end