alchemy_cms 2.9.1 → 3.0.0.rc5

data/spec/models/picture_spec.rb

@@ -11,7 +11,7 @@ module Alchemy
     let(:picture) { Picture.new }
 
     it "is valid with valid attributes" do
-      picture = Picture.new(:image_file => image_file)
+      picture = Picture.new(image_file: image_file)
       picture.should be_valid
     end
 
@@ -22,64 +22,57 @@ module Alchemy
 
     it "is valid with capitalized image file extension" do
       image_file = File.new(File.expand_path('../../fixtures/image2.PNG', __FILE__))
-      picture = Picture.new(:image_file => image_file)
+      picture = Picture.new(image_file: image_file)
       picture.should be_valid
     end
 
     it "is valid with jpeg image file extension" do
       image_file = File.new(File.expand_path('../../fixtures/image3.jpeg', __FILE__))
-      picture = Picture.new(:image_file => image_file)
+      picture = Picture.new(image_file: image_file)
       picture.should be_valid
     end
 
     describe '#suffix' do
-
       it "should return the suffix of original filename" do
-        pic = stub_model(Picture, :image_file_name => 'kitten.JPG')
-        pic.stub(:image_file).and_return(OpenStruct.new({:ext => 'jpg'}))
+        pic = stub_model(Picture, image_file_name: 'kitten.JPG')
+        pic.stub(:image_file).and_return(OpenStruct.new({ext: 'jpg'}))
         pic.suffix.should == "jpg"
       end
 
       context "image has no suffix" do
         it "should return empty string" do
-          pic = stub_model(Picture, :image_file_name => 'kitten')
-          pic.stub(:image_file).and_return(OpenStruct.new({:ext => ''}))
+          pic = stub_model(Picture, image_file_name: 'kitten')
+          pic.stub(:image_file).and_return(OpenStruct.new({ext: ''}))
           pic.suffix.should == ""
         end
       end
-
     end
 
     describe '#humanized_name' do
-
       it "should return a humanized version of original filename" do
-        pic = stub_model(Picture, :image_file_name => 'cute_kitten.JPG')
-        pic.stub(:image_file).and_return(OpenStruct.new({:ext => 'jpg'}))
+        pic = stub_model(Picture, image_file_name: 'cute_kitten.JPG')
+        pic.stub(:image_file).and_return(OpenStruct.new({ext: 'jpg'}))
         pic.humanized_name.should == "cute kitten"
       end
 
       it "should not remove incidents of suffix from filename" do
-        pic = stub_model(Picture, :image_file_name => 'cute_kitten_mo.jpgi.JPG')
-        pic.stub(:image_file).and_return(OpenStruct.new({:ext => 'jpg'}))
+        pic = stub_model(Picture, image_file_name: 'cute_kitten_mo.jpgi.JPG')
+        pic.stub(:image_file).and_return(OpenStruct.new({ext: 'jpg'}))
         pic.humanized_name.should == "cute kitten mo.jpgi"
         pic.humanized_name.should_not == "cute kitten moi"
       end
 
       context "image has no suffix" do
         it "should return humanized name" do
-          pic = stub_model(Picture, :image_file_name => 'cute_kitten')
+          pic = stub_model(Picture, image_file_name: 'cute_kitten')
           pic.stub(:suffix).and_return("")
           pic.humanized_name.should == "cute kitten"
         end
       end
-
     end
 
     describe '#security_token' do
-
-      before do
-        @pic = stub_model(Picture, :id => 1)
-      end
+      before { @pic = stub_model(Picture, id: 1) }
 
       it "should return a sha1 hash" do
         @pic.security_token.should match(/\b([a-f0-9]{16})\b/)
@@ -90,22 +83,28 @@ module Alchemy
       end
 
       it "should convert crop true value into string" do
-        digest = PictureAttributes.secure({:id => @pic.id, :crop => 'crop'})
-        @pic.security_token(:crop => true).should == digest
+        digest = PictureAttributes.secure({id: @pic.id, crop: 'crop'})
+        @pic.security_token(crop: true).should == digest
       end
 
       it "should always include picture id" do
-        digest = PictureAttributes.secure({:id => @pic.id})
+        digest = PictureAttributes.secure({id: @pic.id})
         @pic.security_token.should == digest
       end
 
+      it "should remove all not suitable options" do
+        digest = PictureAttributes.secure({id: @pic.id})
+        @pic.security_token({foo: 'baz'}).should == digest
+      end
+
+      it "should remove all option values that have nil values" do
+        digest = PictureAttributes.secure({id: @pic.id})
+        @pic.security_token({crop: nil}).should == digest
+      end
     end
 
     describe '.filtered_by' do
-
-      let :picture do
-        FactoryGirl.build_stubbed(:picture)
-      end
+      let(:picture) { FactoryGirl.build_stubbed(:picture) }
 
       context "with 'recent' as argument" do
         it 'should call the .recent scope' do
@@ -130,18 +129,17 @@ module Alchemy
 
       context "with no argument" do
         it 'should return the scoped collection' do
-          Picture.should_receive(:scoped).and_return(picture)
+          Picture.should_receive(:all).and_return(picture)
           Picture.filtered_by('').should eq(picture)
         end
       end
     end
 
     describe '.last_upload' do
-
       it "should return all pictures that have the same upload-hash as the most recent picture" do
-        other_upload = Picture.create!(:image_file => image_file, :upload_hash => '456')
-        same_upload = Picture.create!(:image_file => image_file, :upload_hash => '123')
-        most_recent = Picture.create!(:image_file => image_file, :upload_hash => '123')
+        other_upload = Picture.create!(image_file: image_file, upload_hash: '456')
+        same_upload = Picture.create!(image_file: image_file, upload_hash: '123')
+        most_recent = Picture.create!(image_file: image_file, upload_hash: '123')
 
         Picture.last_upload.should include(most_recent)
         Picture.last_upload.should include(same_upload)
@@ -149,15 +147,13 @@ module Alchemy
 
         [other_upload, same_upload, most_recent].each { |p| p.destroy }
       end
-
     end
 
     describe '.recent' do
-
       before do
         now = Time.now
-        @recent = Picture.create!(:image_file => image_file)
-        @old_picture = Picture.create!(:image_file => image_file)
+        @recent = Picture.create!(image_file: image_file)
+        @old_picture = Picture.create!(image_file: image_file)
         @recent.update_column(:created_at, now-23.hours)
         @old_picture.update_column(:created_at, now-10.days)
       end
@@ -169,28 +165,27 @@ module Alchemy
       it "should not return old pictures" do
         Picture.recent.should_not include(@old_picture)
       end
-
     end
 
     describe '#destroy' do
       context "a picture that is assigned in an essence" do
-
         let(:essence_picture) { EssencePicture.create }
         let(:picture) { FactoryGirl.create :picture }
-        before { essence_picture.update_attributes(:picture_id => picture.id) }
+
+        before do
+          essence_picture.update_attributes(picture_id: picture.id)
+        end
 
         it "should raise error message" do
           expect { picture.destroy }.to raise_error PictureInUseError
         end
-
       end
     end
 
     describe '#default_mask' do
-
       before do
-        picture.stub!(:image_file_width).and_return(200)
-        picture.stub!(:image_file_height).and_return(100)
+        picture.stub(:image_file_width).and_return(200)
+        picture.stub(:image_file_height).and_return(100)
       end
 
       it "should return a Hash" do
@@ -214,11 +209,9 @@ module Alchemy
           expect(picture.default_mask('50x100')).to eq({x1: 75, y1: 0, x2: 125, y2: 100})
         end
       end
-
     end
 
     describe "#cropped_thumbnail_size" do
-
       context "if given size is blank or 111x93" do
         it "should return the default size of '111x93'" do
           expect(picture.cropped_thumbnail_size('')).to eq('111x93')
@@ -246,5 +239,167 @@ module Alchemy
       end
     end
 
+    describe '#update_name_and_tag_list!' do
+      let(:picture) { Picture.new(image_file: image_file) }
+
+      before { picture.stub(save!: true) }
+
+      it "updates tag_list" do
+        picture.should_receive(:tag_list=).with('Foo')
+        picture.update_name_and_tag_list!({pictures_tag_list: 'Foo'})
+      end
+
+      context 'name is present' do
+        it "updates name" do
+          picture.should_receive(:name=).with('Foo')
+          picture.update_name_and_tag_list!({pictures_name: 'Foo'})
+        end
+      end
+
+      context 'name is not present' do
+        it "does not update name" do
+          picture.should_not_receive(:name=).with('Foo')
+          picture.update_name_and_tag_list!({pictures_name: ''})
+        end
+      end
+    end
+
+    describe '#urlname' do
+      subject { picture.urlname }
+
+      let(:picture) { build_stubbed(:picture, name: 'Cute kittens.jpg') }
+
+      it "returns a uri escaped name" do
+        should eq('Cute+kittens')
+      end
+
+      context 'with blank name' do
+        let(:picture) { build_stubbed(:picture, name: '') }
+
+        it "returns generic name" do
+          should eq("image_#{picture.id}")
+        end
+      end
+    end
+
+    describe '#to_jq_upload' do
+      subject { picture.to_jq_upload }
+
+      let(:picture) { build_stubbed(:picture, image_file_name: 'cute-kittens.jpg', image_file_size: 1024) }
+
+      it "returns a hash containing data for jquery fileuploader" do
+        should be_an_instance_of(Hash)
+        should include(name: picture.image_file_name)
+        should include(size: picture.image_file_size)
+      end
+
+      context 'with error' do
+        let(:picture) { build_stubbed(:picture) }
+
+        before do
+          picture.stub(errors: {image_file: %w(stupid_cats)})
+        end
+
+        it "returns hash with error message" do
+          should be_an_instance_of(Hash)
+          should include(error: 'stupid_cats')
+        end
+      end
+    end
+
+    describe '#landscape_format?' do
+      subject { picture.landscape_format? }
+
+      let(:picture) { build_stubbed(:picture) }
+
+      context 'image has landscape format' do
+        before { picture.stub_chain(:image_file, :landscape?).and_return(true) }
+        it { should be_true }
+      end
+
+      context 'image has portrait format' do
+        before { picture.stub_chain(:image_file, :landscape?).and_return(false) }
+        it { should be_false }
+      end
+
+      it "is aliased as landscape?" do
+        picture.respond_to?(:landscape?).should be_true
+      end
+    end
+
+    describe '#portrait_format?' do
+      subject { picture.portrait_format? }
+
+      let(:picture) { build_stubbed(:picture) }
+
+      context 'image has portrait format' do
+        before { picture.stub_chain(:image_file, :portrait?).and_return(true) }
+        it { should be_true }
+      end
+
+      context 'image has landscape format' do
+        before { picture.stub_chain(:image_file, :portrait?).and_return(false) }
+        it { should be_false }
+      end
+
+      it "is aliased as portrait?" do
+        picture.respond_to?(:portrait?).should be_true
+      end
+    end
+
+    describe '#square_format?' do
+      subject { picture.square_format? }
+
+      let(:picture) { build_stubbed(:picture) }
+
+      context 'image has square format' do
+        before { picture.stub_chain(:image_file, :aspect_ratio).and_return(1.0) }
+        it { should be_true }
+      end
+
+      context 'image has rectangle format' do
+        before { picture.stub_chain(:image_file, :aspect_ratio).and_return(1.8) }
+        it { should be_false }
+      end
+
+      it "is aliased as square?" do
+        picture.respond_to?(:square?).should be_true
+      end
+    end
+
+    describe '#restricted?' do
+      subject { picture.restricted? }
+
+      let(:picture) { build_stubbed(:picture) }
+
+      context 'is assigned on pages' do
+        before { picture.stub_chain(:pages, :any?).and_return(true) }
+
+        context 'that are all restricted' do
+          before { picture.stub_chain(:pages, :not_restricted, :blank?).and_return(true) }
+          it { should be_true }
+        end
+
+        context 'that are not all restricted' do
+          before { picture.stub_chain(:pages, :not_restricted, :blank?).and_return(false) }
+          it { should be_false }
+        end
+      end
+
+      context 'is not assigned on any page' do
+        before { picture.stub_chain(:pages, :any?).and_return(false) }
+        it { should be_false }
+      end
+    end
+
+    describe '.find_paginated' do
+      subject { Picture.find_paginated({query: 'kitten'}, 5) }
+
+      it "finds pages by name" do
+        Picture.should_receive(:named).with('kitten').and_return(Picture.none)
+        subject
+      end
+    end
+
   end
 end

data/spec/models/resource_spec.rb

@@ -50,13 +50,6 @@ module Alchemy
       end
     end
 
-    describe "#permission_scope" do
-      it "should set an instance variable that holds the permission scope for declarative authorization" do
-        resource.permission_scope
-        resource.instance_variable_get(:@_permission).should == :admin_events
-      end
-    end
-
     describe "#namespace_for_scope" do
       it "should return the namespace" do
         resource.namespace_for_scope.should == ["admin"]
@@ -92,13 +85,12 @@ module Alchemy
         end
       end
 
-      context "when resource_relations defined as class-method in the model" do
+      context "when alchemy_resource_relations defined as class-method in the model" do
         before do
-          ::ActiveSupport::Deprecation.silenced = true
           Event.class_eval do
-            def self.resource_relations
+            def self.alchemy_resource_relations
               {
-                :location => {:attr_method => "location#name", :attr_type => :string}
+                :location => {:attr_method => "name", :attr_type => :string}
               }
             end
           end
@@ -124,17 +116,6 @@ module Alchemy
           relation[:name].should == 'location'
         end
 
-        context "with old hash delimited attr_method style" do
-          it "should show deprecation warnings" do
-            ActiveSupport::Deprecation.should_receive(:warn)
-            resource.resource_relations
-          end
-
-          it "should return the last part as attr_method" do
-            resource.resource_relations[:location_id][:attr_method].should == 'name'
-          end
-        end
-
         context "#attributes" do
           it "should contain the relation" do
             resource.attributes.detect { |a| a[:name] == 'location_id' }.keys.should include(:relation)
@@ -146,10 +127,9 @@ module Alchemy
         end
 
         after do
-          ::ActiveSupport::Deprecation.silenced = false
           Event.class_eval do
             class << self
-              undef :resource_relations
+              undef :alchemy_resource_relations
             end
           end
         end

data/spec/models/site_spec.rb

@@ -16,7 +16,7 @@ module Alchemy
         context 'when it has no languages yet' do
           it 'should automatically create a default language' do
             subject.save!
-            subject.languages.count.should == 1
+            subject.languages.length.should == 1 # using count returns 0, although the resulting array has a length of 1 / O.o
             subject.languages.first.should be_default
           end
         end
@@ -79,14 +79,14 @@ module Alchemy
       context 'when set to a site' do
         before { Site.current = site }
         specify "Language should be scoped to that site" do
-          Language.scoped.to_sql.should match(/alchemy_languages.+site_id.+#{site.id}/)
+          Language.all.to_sql.should match(/alchemy_languages.+site_id.+#{site.id}/)
         end
       end
 
       context 'when set to nil' do
         before { Site.current = nil }
         specify "Language should not be scoped to a site" do
-          Language.scoped.to_sql.should_not match(/alchemy_languages.+site_id.+#{site.id}/)
+          Language.all.to_sql.should_not match(/alchemy_languages.+site_id.+#{site.id}/)
         end
 
         it "should return default site" do
@@ -118,6 +118,72 @@ module Alchemy
       end
     end
 
+    describe '.layout_definitions' do
+      # To prevent memoization across specs
+      before { Site.instance_variable_set("@layout_definitions", nil) }
+
+      subject { Site.layout_definitions }
+
+      context "with file present" do
+        let(:definitions) { [{'name' => 'lala'}] }
+        before { YAML.should_receive(:load_file).and_return(definitions) }
+        it { should == definitions }
+      end
+
+      context "with empty file" do
+        before { YAML.should_receive(:load_file).and_return(false) }
+        it { should == [] }
+      end
+
+      context "with no file present" do
+        it { should == [] }
+      end
+    end
+
+    describe '.layout_definitions' do
+      # To prevent memoization across specs
+      before { Site.instance_variable_set("@layout_definitions", nil) }
+
+      subject { Site.layout_definitions }
+
+      context "with file present" do
+        let(:definitions) { [{'name' => 'lala'}] }
+        before { YAML.should_receive(:load_file).and_return(definitions) }
+        it { should == definitions }
+      end
+
+      context "with empty file" do
+        before { YAML.should_receive(:load_file).and_return(false) }
+        it { should == [] }
+      end
+
+      context "with no file present" do
+        it { should == [] }
+      end
+    end
+
+    describe '.layout_definitions' do
+      # To prevent memoization across specs
+      before { Site.instance_variable_set("@layout_definitions", nil) }
+
+      subject { Site.layout_definitions }
+
+      context "with file present" do
+        let(:definitions) { [{'name' => 'lala'}] }
+        before { YAML.should_receive(:load_file).and_return(definitions) }
+        it { should == definitions }
+      end
+
+      context "with empty file" do
+        before { YAML.should_receive(:load_file).and_return(false) }
+        it { should == [] }
+      end
+
+      context "with no file present" do
+        it { should == [] }
+      end
+    end
+
     describe '#current?' do
       subject { site.current? }