cmsimple 0.2.0

data/spec/javascripts/spec_helper.coffee

@@ -0,0 +1,25 @@
+# You can require javascript files here. A good place to start is by requiring your application.js.
+# require application
+#
+# Teabag includes some support files, but you can use anything from your own support path too.
+# require support/jasmine-jquery
+# require support/sinon
+# require support/your-support-file
+#
+# Deferring execution
+# If you're using CommonJS, RequireJS or some other asynchronous library you can defer execution. Call Teabag.execute()
+# after everything has been loaded. Simple example of a timeout:
+#
+# Teabag.defer = true
+# setTimeout(Teabag.execute, 1000)
+#
+# Matching files
+# By default Teabag will look for files that match _spec.{js,js.coffee,.coffee}. Add a filename_spec.js file in your
+# spec path and it'll be included in the default suite automatically. If you want to customize suites, check out the
+# configuration in config/initializers/teabag.rb
+#
+# Manifest
+# If you'd rather require your spec files manually (to control order for instance) you can disable the suite matcher in
+# the configuration and use this file as a manifest.
+#
+# For more information: http://github.com/modeset/teabag

data/spec/javascripts/support/stubs.coffee

@@ -0,0 +1,16 @@
+@.stubs = {}
+stubs.ajax = ->
+  jqXHR = $.Deferred()
+
+  $.extend jqXHR,
+    readyState: 0
+    setRequestHeader: -> @
+    getAllResponseHeaders: -> null
+    getResponseHeader: -> null
+    overrideMimeType: -> @
+    abort: -> @
+    success: jqXHR.done
+    error: jqXHR.fail
+    complete: jqXHR.done
+
+  spyOn($, "ajax").andReturn(jqXHR)

data/spec/lib/page_responder_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Cmsimple::PageResponder do
+  let(:controller) { OpenStruct.new request: OpenStruct.new(params: @params || {}),
+                                    current_page: @page,
+                                    in_editor_iframe?: @editable }
+
+  it 'raises ActiveRecord::RecordnotFound if the page is not viewable' do
+    responder = Cmsimple::PageResponder.new(controller)
+    responder.should_receive(:current_page_is_viewable?).and_return(false)
+    expect { responder.respond }.to raise_error(ActiveRecord::RecordNotFound)
+  end
+
+  describe 'current page is viewable' do
+    let(:responder) { responder = Cmsimple::PageResponder.new(controller) }
+    it 'is viewable if the request is in the editor iframe' do
+      @editable = true
+      responder.current_page_is_viewable?.should be_true
+    end
+
+    it 'is viewable if the page is published' do
+      @editable = false
+      @page = mock('page', :published? => true)
+      responder.current_page_is_viewable?.should be_true
+    end
+
+    it 'is not viewable if the request is not the editor iframe and the page is not published' do
+      @editable = false
+      @page = mock('page', :published? => false)
+      responder.current_page_is_viewable?.should be_false
+    end
+  end
+
+  describe 'page for context' do
+    let(:responder) { responder = Cmsimple::PageResponder.new(controller) }
+    it 'tries to use the published version of the page if the app is not in edit mode' do
+      @editable = false
+      @page = mock('page', :published? => true)
+      @page.should_receive(:as_published!).and_return(true)
+      responder.page_for_context
+    end
+
+    it 'tries to use the published version of the page if the app is not in edit mode' do
+      @editable = true
+      @page = mock('page', :published? => true)
+      @params = {version: 1}
+      @page.should_receive(:at_version!).and_return(true)
+      responder.page_for_context
+    end
+
+    it 'uses the current draft version by default' do
+      @editable = true
+      @page = mock('page', :published? => false)
+      responder.should_receive(:draft_context?)
+      responder.page_for_context
+    end
+  end
+end

data/spec/lib/regions_proxy_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+describe Cmsimple::RegionsProxy do
+
+  describe 'region proxy' do
+    it 'defines instance methods for each region in the hash' do
+      regions = Cmsimple::RegionsProxy.new content: {value: 'hello'}
+      regions.should respond_to :content
+    end
+
+    it 'defines instance methods for each region in the hash' do
+      regions = Cmsimple::RegionsProxy.new content: {value: 'hello'}
+      regions.content.should be_a(Cmsimple::Region)
+    end
+
+    it 'returns a NillRegion if no region present' do
+      regions = Cmsimple::RegionsProxy.new nil
+      regions.content.should be_a(Cmsimple::Region)
+    end
+  end
+
+  describe '#snippets_hash' do
+    before do
+      @regions = Cmsimple::RegionsProxy.new(
+                                        content: {value: "<div>some content</div><div>[snippet_0/0]</div>",
+                                              snippets: {snippet_0: {name: 'example',
+                                                                     options: { first_name: 'Fred',
+                                                                                last_name: 'Flinstone'
+                                              }}}},
+                                        header: {value: "<div>some content</div><div>[snippet_1/0]</div>",
+                                              snippets: {snippet_1: {name: 'example',
+                                                                     options: { first_name: 'Fred',
+                                                                                last_name: 'Flinstone'
+                                              }}}}
+                                           )
+    end
+
+    it "pull each snippet up into a single hash" do
+      @regions.snippets_hash.should have_key(:snippet_1)
+      @regions.snippets_hash.should have_key(:snippet_0)
+    end
+
+    it "has only the snippets in the hash" do
+      @regions.snippets_hash.keys.length.should == 2
+    end
+  end
+
+end

data/spec/models/image_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+describe Cmsimple::Image do
+  include CarrierWave::Test::Matchers
+
+  before do
+    @file_fixture_path = Cmsimple::Engine.root.join('spec', 'fixtures', 'rails.png')
+    @file_fixture = File.open(@file_fixture_path)
+  end
+
+  after do
+    @file_fixture.close
+    Cmsimple::Image.all.each { |img| img.attachment.remove! }
+  end
+
+  subject { Cmsimple::Image.new }
+  it { should validate_presence_of(:attachment) }
+
+  describe 'image attachment uploader' do
+    it 'has an uploader mounted to attachment' do
+      subject.attachment.should be_a(ImageAttachmentUploader)
+    end
+  end
+
+  describe 'attachment attributes' do
+    before do
+      @image = Cmsimple::Image.new attachment: @file_fixture
+      @image.save!
+    end
+
+    it 'sets content_type from the file' do
+      @image.content_type.should == 'image/png'
+    end
+
+    it 'sets file_size from the file' do
+      @image.file_size.should == @file_fixture.size
+    end
+
+    it 'sets width from the file' do
+      @image.width.should == 50
+    end
+
+    it 'sets height from the file' do
+      @image.height.should == 64
+    end
+  end
+end

data/spec/models/page_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+describe Cmsimple::Page do
+  subject { Cmsimple::Page.new }
+  it {should validate_presence_of(:title) }
+  it {should have_many(:children)}
+  it {should belong_to(:parent)}
+  it {should have_many(:versions)}
+
+  describe '#update_content' do
+    before do
+      subject.uri = '/about'
+      subject.save
+    end
+
+    it "updates content to a hash when json is given to #update_content" do
+      subject.update_content({'content' => 'hello world'})
+      subject.content.should be_a Hash
+      subject.content['content'].should == 'hello world'
+    end
+  end
+
+  describe '#descendants' do
+    before do
+      @childless = Cmsimple::Page.create(title: 'Misc', uri: '/Misc')
+      @page = Cmsimple::Page.create(title: 'Home', uri: '/')
+      @child = Cmsimple::Page.create(title: 'About', uri: '/about')
+      @page.children << @child
+      @descendant = Cmsimple::Page.create(title: 'Contact', uri: '/about/contact')
+      @child.children << @descendant
+    end
+
+    it 'retrieves all the descendants for a page' do
+      @page.descendants.map(&:title).should =~ ['About', 'Contact']
+    end
+
+    it 'returns nothing for a page with no descendants' do
+      @childless.descendants.should be_empty
+    end
+
+    describe '.for_parent_select' do
+      it 'only returns pages that arent direct descendants' do
+        Cmsimple::Page.for_parent_select(@page).map(&:title).should =~ ['Misc']
+        Cmsimple::Page.for_parent_select(@child).map(&:title).should =~ ['Misc', 'Home']
+        Cmsimple::Page.for_parent_select(@childless).map(&:title).should =~ ['Home', 'About', 'Contact']
+      end
+    end
+
+    describe '#root' do
+      it "returns the root of the page tree" do
+        @descendant.root.id.should == @page.id
+      end
+
+      it "returns the current page if it is a root" do
+        @page.root.id.should == @page.id
+      end
+    end
+  end
+
+  describe 'path generation' do
+
+    it 'returns a default slug from the title' do
+      subject.title = 'About Us'
+      subject.slug.should == 'about-us'
+    end
+
+    it "doesn't override the slug if it is manually set" do
+      subject.slug = 'about'
+      subject.title = 'About Us'
+      subject.slug.should == 'about'
+    end
+
+    it 'saves the default slug' do
+      subject.title = 'About Us'
+      subject.save
+      Cmsimple::Page.find(subject.id).slug.should == 'about-us'
+    end
+
+    it 'sets the path to the the slug on save if no parent' do
+      subject.title = 'About Us'
+      subject.save
+      Cmsimple::Page.find(subject.id).uri.should == '/about-us'
+    end
+
+    it 'sets the path to the the slug on save if no parent' do
+      about = Cmsimple::Page.create title: 'About'
+      subject.parent = about
+      subject.title = 'Contact Us'
+      subject.save
+      Cmsimple::Page.find(subject.id).uri.should == '/about/contact-us'
+    end
+  end
+
+  describe 'can only have one root page' do
+    before do
+      subject.title = 'About Us'
+      subject.is_root = true
+      subject.save
+    end
+
+    it 'can only have one root' do
+      Cmsimple::Page.create title: 'About', is_root: true
+      Cmsimple::Page.where(is_root: true).count.should == 1
+    end
+
+    it 'must have at least one root' do
+      subject.is_root = false
+      subject.should_not be_valid
+    end
+  end
+
+  describe 'paths' do
+    it 'creates a path after save' do
+      expect { Cmsimple::Page.create title: 'About' }.to change{ Cmsimple::Path.count }.by(1)
+    end
+
+    it "doesn't create a path if one already exists with the same uri" do
+      Cmsimple::Path.create uri: '/about', redirect_uri: '/'
+      expect { Cmsimple::Page.create title: 'About' }.to change{ Cmsimple::Path.count }.by(0)
+    end
+  end
+
+  describe 'publishing' do
+    let(:page) { Cmsimple::Page.create title: 'About' }
+
+    it "has published_at set to nil by default" do
+      page.published_at.should be_nil
+    end
+
+    describe '#publish!' do
+      it 'sets the published_at date to now' do
+        Timecop.freeze(Time.now) do
+          page.publish!
+          page.published_at.to_s.should == Time.zone.now.to_s
+        end
+      end
+
+      it 'creates a new published verson' do
+        expect { page.publish! }.to change { page.versions.count }.by(1)
+      end
+    end
+
+    describe '#unpublished_changes?' do
+      it 'has unpublished changes if it was never published' do
+        page.published_at.should be_nil
+        page.unpublished_changes?.should be_true
+      end
+
+      it 'does not have unpublished changes once it is published' do
+        page.publish!
+        page.unpublished_changes?.should be_false
+      end
+    end
+
+    describe '#unpublish!' do
+      before do
+        page.publish!
+      end
+
+      it 'sets published_at to nil' do
+        page.unpublish!
+        page.published_at.should be_nil
+      end
+    end
+
+    describe 'published scope' do
+      it 'returns the published page' do
+        page.publish!
+        Cmsimple::Page.published.first.should == page
+      end
+
+      it 'does not return the page if it is not published' do
+        Cmsimple::Page.published.first.should be_nil
+      end
+
+      it 'does not return the page if it is to be published in the future' do
+        page.published_at = 2.weeks.from_now
+        page.save!
+        Cmsimple::Page.published.first.should be_nil
+      end
+    end
+
+    describe 'consuming published content' do
+      before do
+        page.update_content({:content => {:value => 'content version 1'}})
+        page.publish!
+      end
+
+      it 'returns puslished content when in published mode if there are unpublished changes' do
+        page.update_content({:content => {:value => 'content version 2'}})
+        page.as_published!
+        page.regions.content.to_s.should == 'content version 1'
+      end
+    end
+  end
+
+  describe 'versioning' do
+    let(:page) { Cmsimple::Page.create title: 'About' }
+
+    before do
+      page.update_content({:content => {:value => 'content version 1'}})
+      page.publish!
+      page.update_content({:content => {:value => 'content version 2'}})
+      page.publish!
+      page.update_content({:content => {:value => 'content version 3'}})
+      page.publish!
+    end
+
+    describe 'can return a page at a specific version' do
+      it 'returns the page with the content from the requested version' do
+        version = page.versions.first
+        page.at_version!(version.id)
+        page.regions.content.to_s.should == 'content version 1'
+      end
+
+      it 'returns the page with the content from another requested version' do
+        version = page.versions.second
+        page.at_version!(version.id)
+        page.regions.content.to_s.should == 'content version 2'
+      end
+    end
+
+    describe 'reverting' do
+      it 'can revert to a specific version' do
+        version = page.versions.first
+        page.revert_to!(version.id)
+        Cmsimple::Page.find(page.id).regions.content.to_s.should == 'content version 1'
+      end
+
+      it 'can not revert to a version that is not from the pages history' do
+        other_page = Cmsimple::Page.create title: 'Contact'
+        other_page.update_content({:content => {:value => 'content version 1'}})
+        other_page.publish!
+        expect{ page.revert_to!(other_page.versions.first.id) }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+  end
+end

data/spec/models/path_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+describe Cmsimple::Path do
+  subject { Cmsimple::Path.new }
+  it { should validate_presence_of(:uri) }
+  it { should belong_to(:page) }
+
+  it 'downcases its URI on save' do
+    page = Cmsimple::Page.create title: 'Test'
+    path = Cmsimple::Path.create page: page, uri: '/TestRedirect'
+    path.uri.should == '/testredirect'
+  end
+
+  describe 'destination' do
+
+    it 'is required' do
+      subject.should_not be_valid
+      subject.errors[:destination].should_not be_empty
+    end
+
+    it 'returns the destination path when a page is associated' do
+      subject.page = Cmsimple::Page.new uri: '/some-path'
+      subject.destination.uri.should == '/some-path'
+    end
+
+    it 'returns the destination path when it is a redirect' do
+      subject.redirect_uri = '/some-other-path'
+      subject.destination.uri.should == '/some-other-path'
+      subject.should be_redirect
+    end
+
+    it 'returns a redirect if the path does not match the page path' do
+      subject.uri = '/path'
+      subject.page = Cmsimple::Page.new uri: '/some-other-path'
+      subject.destination.should be_a(Cmsimple::Path::Redirect)
+      subject.should be_redirect
+    end
+
+  end
+
+  describe 'from_request' do
+
+    it 'returns the path that has a uri mathing the request path' do
+      subject.uri = '/path'
+      subject.redirect_uri = '/some-other-path'
+      subject.save
+      Cmsimple::Path.from_request(OpenStruct.new(path: '/path')).destination.uri.should == '/some-other-path'
+    end
+
+    it "returns the path with the associated page" do
+      page = Cmsimple::Page.create title: 'About'
+      Cmsimple::Path.create uri: '/about', page: page
+      Cmsimple::Path.from_request(OpenStruct.new(path: '/about')).destination.title.should == 'About'
+    end
+
+    it "returns the path where the associated page is marked as root" do
+      page = Cmsimple::Page.create title: 'Home', is_root: true
+      Cmsimple::Path.create uri: '/home', page: page
+      Cmsimple::Path.from_request(OpenStruct.new(path: '/')).destination.title.should == 'Home'
+    end
+
+    it "normalizes the path before querying" do
+      subject.uri = '/path'
+      subject.redirect_uri = '/some-other-path'
+      subject.save
+      Cmsimple::Path.from_request(OpenStruct.new(path: '//path')).destination.uri.should == '/some-other-path'
+      Cmsimple::Path.from_request(OpenStruct.new(path: '//path/')).destination.uri.should == '/some-other-path'
+      Cmsimple::Path.from_request(OpenStruct.new(path: 'path')).destination.uri.should == '/some-other-path'
+      Cmsimple::Path.from_request(OpenStruct.new(path: '/Path')).destination.uri.should == '/some-other-path'
+    end
+  end
+end