alchemy_cms 3.2.1 → 3.3.0.rc1

data/spec/models/{element_to_page_spec.rb → alchemy/element_to_page_spec.rb}

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Alchemy
   describe ElementToPage do
-
     # ClassMethods
 
     describe '.table_name' do

data/spec/models/{essence_date_spec.rb → alchemy/essence_date_spec.rb}

@@ -6,7 +6,7 @@ module Alchemy
 
     it_behaves_like "an essence" do
       let(:essence)          { EssenceDate.new }
-      let(:ingredient_value) { DateTime.now }
+      let(:ingredient_value) { DateTime.current }
     end
 
     describe '#preview_text' do
@@ -18,12 +18,11 @@ module Alchemy
 
       context "if date set" do
         it "should format the date by i18n" do
-          essence.date = DateTime.now
+          essence.date = DateTime.current
           expect(::I18n).to receive(:l).with(essence.date, format: :date)
           essence.preview_text
         end
       end
     end
-
   end
 end

data/spec/models/{essence_file_spec.rb → alchemy/essence_file_spec.rb}

@@ -2,8 +2,7 @@ require 'spec_helper'
 
 module Alchemy
   describe EssenceFile do
-
-    let(:attachment) { build_stubbed(:attachment) }
+    let(:attachment) { build_stubbed(:alchemy_attachment) }
     let(:essence)    { EssenceFile.new(attachment: attachment) }
 
     it_behaves_like "an essence" do
@@ -15,7 +14,7 @@ module Alchemy
       subject { essence.attachment_url }
 
       it "returns the download attachment url." do
-        is_expected.to match(/\/attachment\/#{attachment.id}\/download\/#{attachment.file_name}/)
+        is_expected.to match(/\/attachment\/#{attachment.id}\/download\/#{attachment.urlname}\.#{attachment.suffix}/)
       end
 
       context 'without attachment assigned' do
@@ -26,7 +25,6 @@ module Alchemy
     end
 
     describe '#preview_text' do
-
       it "returns the attachment's name as preview text" do
         expect(essence.preview_text).to eq(attachment.name)
       end
@@ -38,6 +36,5 @@ module Alchemy
         end
       end
     end
-
   end
 end

data/spec/models/{essence_html_spec.rb → alchemy/essence_html_spec.rb}

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Alchemy
   describe EssenceHtml do
-    let (:essence) { EssenceHtml.new(source: '<p>hello!</p>') }
+    let(:essence) { EssenceHtml.new(source: '<p>hello!</p>') }
 
     it_behaves_like "an essence" do
       let(:essence)          { EssenceHtml.new }

data/spec/models/{essence_picture_spec.rb → alchemy/essence_picture_spec.rb}

@@ -8,25 +8,25 @@ module Alchemy
     end
 
     it_behaves_like "has image transformations" do
-      let(:picture) { build_stubbed(:essence_picture) }
+      let(:picture) { build_stubbed(:alchemy_essence_picture) }
     end
 
     it "should not store negative values for crop values" do
-      essence = EssencePicture.new(:crop_from => '-1x100', :crop_size => '-20x30')
+      essence = EssencePicture.new(crop_from: '-1x100', crop_size: '-20x30')
       essence.save!
       expect(essence.crop_from).to eq("0x100")
       expect(essence.crop_size).to eq("0x30")
     end
 
     it "should not store float values for crop values" do
-      essence = EssencePicture.new(:crop_from => '0.05x104.5', :crop_size => '99.5x203.4')
+      essence = EssencePicture.new(crop_from: '0.05x104.5', crop_size: '99.5x203.4')
       essence.save!
       expect(essence.crop_from).to eq("0x105")
       expect(essence.crop_size).to eq("100x203")
     end
 
     it "should convert newlines in caption into <br/>s" do
-      essence = EssencePicture.new(:caption => "hello\nkitty")
+      essence = EssencePicture.new(caption: "hello\nkitty")
       essence.save!
       expect(essence.caption).to eq("hello<br/>kitty")
     end
@@ -35,8 +35,8 @@ module Alchemy
       subject { essence.picture_url(options) }
 
       let(:options) { {} }
-      let(:picture) { build_stubbed(:picture) }
-      let(:essence) { build_stubbed(:essence_picture, picture: picture) }
+      let(:picture) { build_stubbed(:alchemy_picture) }
+      let(:essence) { build_stubbed(:alchemy_essence_picture, picture: picture) }
 
       it "returns the show picture url." do
         is_expected.to match(/\/pictures\/#{picture.id}\/show\/#{picture.urlname}\.#{Config.get(:image_output_format)}/)
@@ -68,33 +68,64 @@ module Alchemy
         end
       end
 
-      context 'with crop sizes set' do
-        before do
-          expect(essence).to receive(:crop_size).at_least(:once).and_return('200x200')
-          expect(essence).to receive(:crop_from).at_least(:once).and_return('10x10')
-        end
+      context 'when cropping is allowed' do
+        let(:options) { {crop: true} }
 
-        it "includes the crop sizes in the url." do
-          is_expected.to match(/200x200/)
-          is_expected.to match(/10x10/)
+        it 'converts the value `true` of the `crop` option into `crop` as part of the url' do
+          is_expected.to match /crop/
+          is_expected.not_to match /true/
         end
 
-        context 'but with crop sizes in the options' do
-          let(:options) { {crop_from: '30x30', crop_size: '75x75'} }
+        context 'and crop sizes are set' do
+          before do
+            expect(essence).to receive(:crop_size).at_least(:once).and_return('200x200')
+            expect(essence).to receive(:crop_from).at_least(:once).and_return('10x10')
+          end
 
-          it "includes these crop sizes instead." do
-            is_expected.to match(/30x30/)
-            is_expected.to match(/75x75/)
+          it "includes the crop sizes in the url." do
+            is_expected.to match(/200x200/)
+            is_expected.to match(/10x10/)
+          end
+
+          context 'but with crop sizes in the options' do
+            before do
+              options.update({crop_from: '30x30', crop_size: '75x75'})
+            end
+
+            it "includes these crop sizes instead." do
+              is_expected.to match(/30x30/)
+              is_expected.to match(/75x75/)
+            end
           end
         end
       end
 
-      context 'with crop true in the options' do
-        let(:options) { {crop: true} }
+      context 'when cropping is prohibited' do
+        before do
+          expect(essence).not_to receive(:crop_size)
+          expect(essence).not_to receive(:crop_from)
+        end
 
-        it 'converts the value into `crop`' do
-          is_expected.to match /crop/
-          is_expected.not_to match /true/
+        context 'without setting `crop` in the options' do
+          it "does not include `crop` in the url" do
+            is_expected.not_to match(/crop/)
+          end
+        end
+
+        context 'when `crop` is explicitly set to `false`' do
+          let(:options) { {crop: false} }
+
+          it "does not include `crop` in the url" do
+            is_expected.not_to match(/crop/)
+          end
+        end
+
+        context 'even when crop sizes are set' do
+          it "does not include any cropping information in the url" do
+            is_expected.not_to match(/crop/)
+            is_expected.not_to match(/200x200/)
+            is_expected.not_to match(/10x10/)
+          end
         end
       end
 
@@ -125,7 +156,7 @@ module Alchemy
       subject { essence.cropping_mask }
 
       context 'with crop values given' do
-        let(:essence) { build_stubbed(:essence_picture, crop_from: '0x0', crop_size: '100x100') }
+        let(:essence) { build_stubbed(:alchemy_essence_picture, crop_from: '0x0', crop_size: '100x100') }
 
         it "returns a hash containing cropping coordinates" do
           is_expected.to eq({x1: 0, y1: 0, x2: 100, y2: 100})
@@ -133,14 +164,14 @@ module Alchemy
       end
 
       context 'with no crop values given' do
-        let(:essence) { build_stubbed(:essence_picture) }
+        let(:essence) { build_stubbed(:alchemy_essence_picture) }
 
         it { is_expected.to be_nil }
       end
     end
 
     describe '#preview_text' do
-      let(:picture) { mock_model(Picture, name: 'Cute Cat Kittens')}
+      let(:picture) { mock_model(Picture, name: 'Cute Cat Kittens') }
       let(:essence) { EssencePicture.new }
 
       it "should return the pictures name as preview text" do
@@ -157,7 +188,7 @@ module Alchemy
 
     describe '#serialized_ingredient' do
       let(:content) { Content.new }
-      let(:picture) { mock_model(Picture, name: 'Cute Cat Kittens', urlname: 'cute-cat-kittens', security_token: 'kljhgfd')}
+      let(:picture) { mock_model(Picture, name: 'Cute Cat Kittens', urlname: 'cute-cat-kittens', security_token: 'kljhgfd') }
       let(:essence) { EssencePicture.new(content: content, picture: picture) }
 
       it "returns the url to render the picture" do
@@ -166,7 +197,7 @@ module Alchemy
 
       context 'with image settings given at content' do
         before do
-          expect(content).to receive(:settings).and_return({size: '150x150', format: 'png', select_values: [1,2,3]})
+          expect(content).to receive(:settings).and_return({size: '150x150', format: 'png', select_values: [1, 2, 3]})
         end
 
         it "returns the url with cropping and resizing options" do
@@ -179,5 +210,46 @@ module Alchemy
       end
     end
 
+    describe "#allow_image_cropping?" do
+      let(:essence_picture) { stub_model(Alchemy::EssencePicture) }
+      let(:content) { stub_model(Alchemy::Content) }
+      let(:picture) { stub_model(Alchemy::Picture) }
+
+      subject { essence_picture.allow_image_cropping? }
+
+      it { is_expected.to be_falsy }
+
+      context "with content existing?" do
+        before do
+          allow(essence_picture).to receive(:content) { content }
+        end
+
+        it { is_expected.to be_falsy }
+
+        context "with picture assigned" do
+          before do
+            allow(essence_picture).to receive(:picture) { picture }
+          end
+
+          it { is_expected.to be_falsy }
+
+          context "and with image larger than crop size" do
+            before do
+              allow(picture).to receive(:can_be_cropped_to) { true }
+            end
+
+            it { is_expected.to be_falsy }
+
+            context "with crop set to true" do
+              before do
+                allow(content).to receive(:settings_value) { true }
+              end
+
+              it { is_expected.to be(true) }
+            end
+          end
+        end
+      end
+    end
   end
 end

data/spec/models/{essence_richtext_spec.rb → alchemy/essence_richtext_spec.rb}

@@ -2,10 +2,12 @@ require 'spec_helper'
 
 module Alchemy
   describe EssenceRichtext do
-    let(:essence) { EssenceRichtext.new(:body => '<h1>Hello!</h1><p>Welcome to Peters Petshop.</p>') }
+    let(:essence) do
+      EssenceRichtext.new(body: '<h1>Hello!</h1><p>Welcome to Peters Petshop.</p>')
+    end
 
     it_behaves_like "an essence" do
-      let(:essence)          { EssenceRichtext.new }
+      let(:essence) { EssenceRichtext.new }
       let(:ingredient_value) { '<h1>Hello!</h1><p>Welcome to Peters Petshop.</p>' }
     end
 
@@ -14,5 +16,8 @@ module Alchemy
       expect(essence.stripped_body).to eq("Hello!Welcome to Peters Petshop.")
     end
 
+    it 'has tinymce enabled' do
+      expect(essence.has_tinymce?).to eq(true)
+    end
   end
 end

data/spec/models/{essence_text_spec.rb → alchemy/essence_text_spec.rb}

@@ -17,12 +17,12 @@ module Alchemy
       end
 
       it "should return a preview text" do
-        expect(essence.preview_text).to eq("#{ingredient_value}")
+        expect(essence.preview_text).to eq(ingredient_value.to_s)
       end
 
       context "with given maxlength" do
         it "should return as much beginning characters as defined with maxlength" do
-          expect(essence.preview_text(2)).to eq("#{ingredient_value}"[0..1])
+          expect(essence.preview_text(2)).to eq(ingredient_value.to_s[0..1])
         end
       end
 
@@ -44,7 +44,6 @@ module Alchemy
 
       context 'essence responds to link_taget' do
         context 'if link_target attribute is set to "blank"' do
-
           before { essence.link_target = 'blank' }
 
           it "should return true" do
@@ -62,10 +61,9 @@ module Alchemy
 
     describe 'validations' do
       describe 'format' do
-
         context 'given a regex string' do
           before do
-            allow(essence).to receive(:description).and_return({'validate' => [{'format' => /\Ahttps:\/\/[\S]+/}]})
+            allow(essence).to receive(:definition).and_return({'validate' => [{'format' => /\Ahttps:\/\/[\S]+/}]})
           end
 
           context 'when ingredient string does not match the given regex' do
@@ -87,7 +85,7 @@ module Alchemy
 
         context 'given a key from the config`s format_matcher list' do
           before do
-            allow(essence).to receive(:description).and_return({'validate' => [{'format' => 'email'}]})
+            allow(essence).to receive(:definition).and_return({'validate' => [{'format' => 'email'}]})
           end
 
           context 'when ingredient string does not match the given format matcher' do
@@ -106,9 +104,7 @@ module Alchemy
             end
           end
         end
-
       end
     end
-
   end
 end

data/spec/models/alchemy/language_spec.rb

@@ -0,0 +1,243 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+module Alchemy
+  describe Language do
+    let(:default_language) { Alchemy::Language.default }
+    let(:language)         { create(:alchemy_language, :klingon) }
+    let(:page)             { create(:alchemy_page, language: language) }
+
+    it 'is valid with uppercase country code' do
+      language = Alchemy::Language.new(
+        country_code: 'AT',
+        language_code: 'de',
+        name: 'Österreich',
+        frontpage_name: 'Start',
+        page_layout: 'index'
+      )
+      expect(language).to be_valid
+    end
+
+    it "should return a label for code" do
+      expect(language.label(:code)).to eq('kl')
+    end
+
+    it "should return a label for name" do
+      expect(language.label(:name)).to eq('Klingon')
+    end
+
+    context "with language_code and empty country_code" do
+      it "#code should return language locale only" do
+        language.country_code = ''
+        expect(language.code).to eq('kl')
+      end
+
+      context "adding a value for country code" do
+        it "#code should return a joined locale" do
+          language.country_code = 'cr'
+          expect(language.code).to eq('kl-cr')
+        end
+
+        it "should update all associated Pages with self.code as value for Page#language_code" do
+          page = create(:alchemy_page, language: language)
+          language.country_code = 'cr'
+          language.save
+          page.reload; expect(page.language_code).to eq('kl-cr')
+        end
+      end
+    end
+
+    context "with country_code and_language_code" do
+      context "removing the country_code" do
+        it "should update all associated Pages´s language_code with Language#code" do
+          language = create(:alchemy_language, country_code: 'kl')
+          language.country_code = ''
+          language.save
+          page.reload; expect(page.language_code).to eq("kl")
+        end
+      end
+    end
+
+    it "should not be deletable if it is the default language" do
+      expect {
+        default_language.destroy
+      }.to raise_error(DefaultLanguageNotDeletable)
+    end
+
+    describe "before save" do
+      describe "#remove_old_default if default attribute has changed to true" do
+        it "should unset the default status of the old default language" do
+          default_language
+          language.update_attributes(default: true)
+          default_language.reload
+          expect(default_language.default).to be_falsey
+        end
+      end
+    end
+
+    context "after_update" do
+      describe "#set_pages_language if language´s code has changed" do
+        it "should update all its pages with the new code" do
+          @other_page = create(:alchemy_page, language: language)
+          language.update_attributes(code: "fo")
+          language.reload; page.reload; @other_page.reload
+          expect([page.language_code, @other_page.language_code]).to eq([language.code, language.code])
+        end
+      end
+
+      describe "#unpublish_pages" do
+        it "should set all pages to unpublic if it gets set to unpublic" do
+          page = create(:alchemy_page, language: language)
+          @other_page = create(:alchemy_page, language: language)
+          language.update_attributes(public: false)
+          language.reload; page.reload; @other_page.reload
+          expect([page.public?, @other_page.public?]).to eq([false, false])
+        end
+      end
+    end
+
+    describe '.find_by_code' do
+      context "with only the language code given" do
+        it "should find the language" do
+          expect(Language.find_by_code(language.code)).to eq(language)
+        end
+      end
+    end
+
+    describe 'validations' do
+      let(:language) { Language.new(default: true, public: false) }
+
+      describe 'publicity_of_default_language' do
+        context 'if language is not published' do
+          it "should add an error to the object" do
+            expect(language.valid?).to eq(false)
+            expect(language.errors.messages).to have_key(:public)
+          end
+        end
+      end
+
+      describe 'presence_of_default_language' do
+        context 'if no default language would exist anymore' do
+          before do
+            allow(Language).to receive(:default).and_return(language)
+            allow(language).to receive(:default_changed?).and_return(true)
+          end
+
+          it "should add an error to the object" do
+            expect(language.valid?).to eq(false)
+            expect(language.errors.messages).to have_key(:default)
+          end
+        end
+      end
+
+      describe 'before' do
+        subject do
+          language.valid?
+          language.locale
+        end
+
+        before do
+          allow(::I18n).to receive(:available_locales) do
+            [:de, :'de-at', :en, :'en-uk']
+          end
+        end
+
+        context 'when locale is already set' do
+          let(:language) do
+            build(:alchemy_language, language_code: 'de', locale: 'de')
+          end
+
+          it 'does not set the locale again' do
+            expect(language).to_not receive(:set_locale)
+          end
+        end
+
+        context 'when code is an available locale' do
+          let(:language) do
+            build(:alchemy_language, language_code: 'de', country_code: 'at')
+          end
+
+          it 'sets the locale to code' do
+            is_expected.to eq('de-at')
+          end
+        end
+
+        context 'when code is not is an available locale, but language_code is' do
+          let(:language) do
+            build(:alchemy_language, language_code: 'de', country_code: 'ch')
+          end
+
+          it 'sets the locale to language code' do
+            is_expected.to eq('de')
+          end
+        end
+
+        context "when language_code is an available locale" do
+          let(:language) do
+            build(:alchemy_language, language_code: 'en')
+          end
+
+          it 'sets the locale to language_code' do
+            is_expected.to eq('en')
+          end
+        end
+
+        context "when neither language_code nor code is an available locale" do
+          it { is_expected.to be_nil }
+        end
+      end
+
+      describe 'presence_of_locale_file' do
+        context "when locale file is missing for selected language code" do
+          let(:language) do
+            build(:alchemy_language, language_code: 'jp')
+          end
+
+          it 'adds errors to locale attribute' do
+            expect(language).to_not be_valid
+            expect(language.errors).to have_key(:locale)
+          end
+        end
+
+        context "when locale file is present for selected language code" do
+          let(:language) do
+            build(:alchemy_language, :klingon)
+          end
+
+          it 'adds no errors to locale attribute' do
+            expect(language).to be_valid
+            expect(language.errors).to_not have_key(:locale)
+          end
+        end
+      end
+    end
+
+    describe '#matching_locales' do
+      let(:language) do
+        build(:alchemy_language, language_code: 'de')
+      end
+
+      subject do
+        language.matching_locales
+      end
+
+      before do
+        expect(::I18n).to receive(:available_locales) do
+          [:de, :'de-at', :'en-uk']
+        end
+      end
+
+      it 'returns locales matching the language code' do
+        is_expected.to eq [:de, :'de-at']
+      end
+
+      context 'when language code is not is an available locale' do
+        let(:language) do
+          build(:alchemy_language, language_code: 'jp')
+        end
+
+        it { is_expected.to eq [] }
+      end
+    end
+  end
+end