locomotive_cms 0.0.3.3 → 0.0.4.beta1

data/spec/lib/locomotive/liquid/filters/html_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
- 
-describe Locomotive::Liquid::Filters::Html do
-  
-  include Locomotive::Liquid::Filters::Html
-  
-  it 'should return a link tag for a stylesheet file' do
-    result = "<link href=\"main.css\" media=\"screen\" rel=\"stylesheet\" type=\"text/css\" />"
-    stylesheet_tag('main.css').should == result
-    stylesheet_tag('main').should == result
-    stylesheet_tag(nil).should == ''
-  end
-  
-  it 'should return a script tag for a javascript file' do
-    result = %{<script src="main.js" type="text/javascript"></script>}
-    javascript_tag('main.js').should == result
-    javascript_tag('main').should == result
-    javascript_tag(nil).should == ''
-  end
-  
-  it 'should return an image tag without paramaters' do
-    image_tag('foo.jpg').should == "<img src=\"/foo.jpg\" />"
-  end
-  
-  it 'should return an image tag with size' do
-    image_tag('foo.jpg', 'width:100', 'height:50').should == "<img src=\"/foo.jpg\" height=\"50\" width=\"100\" />"
-  end
-  
-  it 'should return a flash tag without parameters' do
-    flash_tag('foo.flv').should == %{
-            <object>
-              <param name="movie" value="foo.flv" />
-              <embed src="foo.flv" />
-              </embed>
-            </object>
-    }.strip
-  end
-  
-  it 'should return a flash tag with size' do
-    flash_tag('foo.flv', 'width:100', 'height:50').should == %{
-            <object height=\"50\" width=\"100\">
-              <param name="movie" value="foo.flv" />
-              <embed src="foo.flv" height=\"50\" width=\"100\" />
-              </embed>
-            </object>
-    }.strip
-  end
-  
-  it 'should return a navigation block for the pagination' do
-    pagination = { 
-      "previous"   => nil, 
-      "parts"     => [
-        { 'title' => '1', 'is_link' => false },
-        { 'title' => '2', 'is_link' => true, 'url' => '/?page=2' },
-        { 'title' => '&hellip;', 'is_link' => false, 'hellip_break' => true },
-        { 'title' => '5', 'is_link' => true, 'url' => '/?page=5' }
-      ],
-      "next" => { 'title' => 'next', 'is_link' => true, 'url' => '/?page=2' }
-    }
-    html = default_pagination(pagination, 'css:flickr_pagination')
-    html.should match(/<div class="pagination flickr_pagination">/)
-    html.should match(/<span class="disabled prev_page">&laquo; Previous<\/span>/)
-    html.should match(/<a href="\/\?page=2">2<\/a>/)    
-    html.should match(/<span class=\"gap\">\&hellip;<\/span>/)
-    html.should match(/<a href="\/\?page=2" class="next_page">Next &raquo;<\/a>/)
-    
-    pagination.merge!({
-      'previous' => { 'title' => 'previous', 'is_link' => true, 'url' => '/?page=4' },
-      'next'     => nil 
-    })
-    
-    html = default_pagination(pagination, 'css:flickr_pagination')
-    html.should_not match(/<span class="disabled prev_page">&laquo; Previous<\/span>/)
-    html.should match(/<a href="\/\?page=4" class="prev_page">&laquo; Previous<\/a>/)
-    html.should match(/<span class="disabled next_page">Next &raquo;<\/span>/)
-    
-    pagination.merge!({ 'parts' => [] })
-    html = default_pagination(pagination, 'css:flickr_pagination')
-    html.should == ''
-  end
-
-end

data/spec/lib/locomotive/liquid/filters/misc_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
- 
-describe Locomotive::Liquid::Filters::Misc do
-  
-  include Locomotive::Liquid::Filters::Misc
-  
-  it 'should underscore an input' do
-    underscore('foo').should == 'foo'
-    underscore('home page').should == 'home_page'
-    underscore('My foo Bar').should == 'my_foo_bar'
-    underscore('foo/bar').should == 'foo_bar'
-    underscore('foo/bar/index').should == 'foo_bar_index'
-  end
-  
-  it 'should dasherize an input' do
-    dasherize('foo').should == 'foo'
-    dasherize('foo_bar').should == 'foo-bar'
-    dasherize('foo/bar').should == 'foo-bar'
-    dasherize('foo/bar/index').should == 'foo-bar-index'
-  end
-  
-  it 'should concat strings' do
-    concat('foo', 'bar').should == 'foobar'
-    concat('hello', 'foo', 'bar').should == 'hellofoobar'
-  end
-  
-  it 'should return the input string every n occurences' do
-    modulo('foo', 0, 3).should == ''
-    modulo('foo', 1, 3).should == ''
-    modulo('foo', 2, 3).should == 'foo'
-    modulo('foo', 3, 3).should == ''
-    modulo('foo', 4, 3).should == ''
-    modulo('foo', 5, 3).should == 'foo'
-  end
-    
-end

data/spec/lib/locomotive/liquid/filters/text_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
- 
-describe Locomotive::Liquid::Filters::Text do
-  
-  include Locomotive::Liquid::Filters::Text
-  
-  it 'transforms a textile input into HTML' do
-    textile('This is *my* text.').should == "<p>This is <strong>my</strong> text.</p>"
-  end
-    
-end

data/spec/lib/locomotive/liquid/tags/consume_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Locomotive::Liquid::Tags::Consume do
-  
-  context '#validating syntax' do
-    
-    it 'validates a basic syntax' do
-      markup = 'blog from "http://blog.locomotiveapp.org"'
-      lambda do
-        Locomotive::Liquid::Tags::Consume.new('consume', markup, ["{% endconsume %}"])
-      end.should_not raise_error
-    end
-    
-    it 'validates more complex syntax with attributes' do
-      markup = 'blog from "http://www.locomotiveapp.org" username: "john", password: "easyone"'
-      lambda do
-        Locomotive::Liquid::Tags::Consume.new('consume', markup, ["{% endconsume %}"])
-      end.should_not raise_error
-    end
-
-    it 'raises an error if the syntax is incorrect' do
-      markup = 'blog from http://www.locomotiveapp.org'
-      lambda do
-        Locomotive::Liquid::Tags::Consume.new('consume', markup, ["{% endconsume %}"])
-      end.should raise_error
-    end
-    
-  end
-    
-  context '#rendering' do
-    
-    it 'puts the response into the liquid variable' do
-      Locomotive::Httparty::Webservice.stubs(:get).returns({ 'title' => 'Locomotive rocks !' })
-      template = "{% consume blog from \"http://blog.locomotiveapp.org/api/read\" %}{{ blog.title }}{% endconsume %}"
-      Liquid::Template.parse(template).render.should == 'Locomotive rocks !'
-    end
-    
-  end
-  
-end

data/spec/lib/locomotive/liquid/tags/nav_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
- 
-describe Locomotive::Liquid::Tags::Nav do
-  
-  before(:each) do
-    @home = Factory.build(:page)
-    @home.stubs(:children).returns([
-      Page.new(:title => 'Child #1', :fullpath => 'child_1', :slug => 'child_1'), 
-      Page.new(:title => 'Child #2', :fullpath => 'child_2', :slug => 'child_2')
-      ])
-    @home.children.last.stubs(:children).returns([
-      Page.new(:title => 'Child #2.1', :fullpath => 'child_2/sub_child_1', :slug => 'sub_child_1'),
-      Page.new(:title => 'Child #2.2', :fullpath => 'child_2/sub_child_2', :slug => 'sub_child_2')
-      ])
-    @site = Factory.build(:site)
-    @site.stubs(:pages).returns([@home])
-  end
-  
-  context '#rendering' do
-
-    it 'renders from site' do
-      render_nav.should == '<ul id="nav"><li id="child-1" class="link"><a href="/child_1">Child #1</a></li><li id="child-2" class="link"><a href="/child_2">Child #2</a></li></ul>'
-    end
-    
-    it 'renders from page' do
-      (page = @home.children.last.children.first).stubs(:parent).returns(@home.children.last)
-      output = render_nav 'page', { :page => page }
-      output.should == '<ul id="nav"><li id="sub-child-1" class="link on"><a href="/child_2/sub_child_1">Child #2.1</a></li><li id="sub-child-2" class="link"><a href="/child_2/sub_child_2">Child #2.2</a></li></ul>'
-    end
-    
-    it 'adds an icon before the link' do
-      render_nav('site', {}, 'icon: true').should match /<li id="child-1" class="link"><a href="\/child_1"><span><\/span>Child #1<\/a>/
-      render_nav('site', {}, 'icon: before').should match /<li id="child-1" class="link"><a href="\/child_1"><span><\/span>Child #1<\/a>/
-    end
-    
-    it 'adds an icon after the link' do
-      render_nav('site', {}, 'icon: after').should match /<li id="child-1" class="link"><a href="\/child_1">Child #1<span><\/span><\/a><\/li>/
-    end    
-    
-  end
-  
-  def render_nav(source = 'site', registers = {}, template_option = '')
-    registers = { :site => @site, :page => @home }.merge(registers)
-    liquid_context = ::Liquid::Context.new({}, registers)
-    
-    output = Liquid::Template.parse("{% nav #{source} #{template_option} %}").render(liquid_context)
-    output.gsub(/\n\s{0,}/, '')
-  end
-    
-end

data/spec/lib/locomotive/liquid/tags/paginate_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
- 
-describe Locomotive::Liquid::Tags::Paginate do
-  
-  it 'should have a valid syntax' do
-    markup = "contents.projects by 5"
-    lambda do
-      Locomotive::Liquid::Tags::Paginate.new('paginate', markup, ["{% endpaginate %}"])
-    end.should_not raise_error
-  end
-  
-  it 'should raise an error if the syntax is incorrect' do
-    ["contents.projects by a", "contents.projects", "contents.projects 5"].each do |markup|
-      lambda do
-        Locomotive::Liquid::Tags::Paginate.new('paginate', markup, ["{% endpaginate %}"])
-      end.should raise_error
-    end
-  end
-  
-  it 'should paginate the collection' do
-    template = Liquid::Template.parse(default_template)
-    text = template.render!(liquid_context)
-    
-    text.should match /!Ruby on Rails!/
-    text.should match /!jQuery!/
-    text.should_not match /!mongodb!/
-    
-    text = template.render!(liquid_context(:page => 2))
-
-    text.should_not match /!jQuery!/    
-    text.should match /!mongodb!/
-    text.should match /!Liquid!/
-    text.should_not match /!sqlite3!/
-  end
-  
-  it 'should not paginate if collection is nil or empty' do
-    template = Liquid::Template.parse(default_template)
-    
-    lambda do
-      template.render!(liquid_context(:collection => nil))
-    end.should raise_error
-    
-    lambda do
-      template.render!(liquid_context(:collection => PaginatedCollection.new))
-    end.should raise_error
-  end
-  
-  # ___ helpers methods ___ #
-  
-  def liquid_context(options = {})
-    ::Liquid::Context.new({
-      'projects'      => options.has_key?(:collection) ? options[:collection] : PaginatedCollection.new(['Ruby on Rails', 'jQuery', 'mongodb', 'Liquid', 'sqlite3']),
-      'current_page'  => options[:page] || 1
-    }, {}, true)
-  end
-  
-  def default_template
-    "{% paginate projects by 2 %}
-      {% for project in paginate.collection %}
-        !{{ project }}!
-      {% endfor %}
-    {% endpaginate %}"
-  end
-  
-  class PaginatedCollection
-    
-    def initialize(collection)
-      @collection = collection || []
-    end
-    
-    def paginate(options = {})
-      total_pages = (@collection.size.to_f / options[:per_page].to_f).to_f.ceil + 1
-      offset = (options[:page] - 1) * options[:per_page]
-      
-      {
-        :collection     => @collection[offset..(offset + options[:per_page]) - 1],
-        :current_page   => options[:page],
-        :previous_page  => options[:page] == 1 ? 1 : options[:page] - 1,
-        :next_page      => options[:page] == total_pages ? total_pages : options[:page] + 1,
-        :total_entries  => @collection.size,
-        :total_pages    => total_pages,
-        :per_page       => options[:per_page]
-      }      
-    end
-    
-    def each(&block)
-      @collection.each(&block)
-    end
-    
-    def method_missing(method, *args)
-      @collection.send(method, *args)
-    end
-    
-    def to_liquid
-      self
-    end
-  end
-  
-end

data/spec/lib/locomotive/liquid/tags/snippet_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
- 
-describe Locomotive::Liquid::Tags::Snippet do
-  
-  before(:each) do
-    Site.any_instance.stubs(:create_default_pages!).returns(true)
-    site = Factory.build(:site)
-    snippet = Factory.build(:snippet, :site => site)
-    snippet.send(:store_template)
-    site.snippets.stubs(:where).returns([snippet])
-    @context = ::Liquid::Context.new({}, { :site => site })
-  end
-  
-  it 'should render it' do
-    template = ::Liquid::Template.parse("{% include 'header' %}")
-    text = template.render(@context)
-    text.should == "<title>Acme</title>"
-  end
-  
-end

data/spec/lib/locomotive/liquid/tags/with_scope_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
- 
-describe Locomotive::Liquid::Tags::WithScope do
-  
-  it 'should decode options (boolean, interger, ...)' do
-    scope = Locomotive::Liquid::Tags::WithScope.new('with_scope', 'active:true price:42 title:\'foo\' hidden:false', ["{% endwith_scope %}"])    
-    attributes = scope.send(:decode, scope.instance_variable_get(:@attributes))
-    attributes['active'].should == true
-    attributes['price'].should == 42
-    attributes['title'].should == 'foo'
-    attributes['hidden'].should == false
-  end
-  
-  it 'should store attributes in the context' do
-    template = ::Liquid::Template.parse("{% with_scope active:true title:'foo' %}{{ with_scope.active }}-{{ with_scope.title }}{% endwith_scope %}")
-    text = template.render
-    text.should == "true-foo"
-  end
-  
-end

data/spec/lib/locomotive/render_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
- 
-describe 'Locomotive rendering system' do
-  
-  before(:each) do  
-    @controller = Locomotive::TestController.new
-    Site.any_instance.stubs(:create_default_pages!).returns(true)
-    @site = Factory.build(:site)
-    Site.stubs(:find).returns(@site)
-    @controller.current_site = @site
-    @page = Factory.build(:page, :site => nil, :published => true)
-  end
-
-  context 'setting the response' do
-    
-    before(:each) do
-      @controller.instance_variable_set(:@page, @page)
-      @controller.send(:prepare_and_set_response, 'Hello world !')
-    end
-    
-    it 'sets the content type to html' do
-      @controller.response.headers['Content-Type'].should == 'text/html; charset=utf-8'
-    end
-    
-    it 'displays the output' do
-      @controller.output.should == 'Hello world !'
-    end
-    
-    it 'does not set the cache' do
-      @controller.response.headers['Cache-Control'].should be_nil
-    end
-        
-    it 'sets the cache by simply using etag' do
-      @page.cache_strategy = 'simple'
-      @page.stubs(:updated_at).returns(Time.now)
-      @controller.send(:prepare_and_set_response, 'Hello world !')
-      @controller.response.to_a # force to build headers
-      @controller.response.headers['Cache-Control'].should == 'public'
-    end
-    
-    it 'sets the cache for Varnish' do
-      @page.cache_strategy = '3600'
-      @page.stubs(:updated_at).returns(Time.now)
-      @controller.send(:prepare_and_set_response, 'Hello world !')
-      @controller.response.to_a # force to build headers
-      @controller.response.headers['Cache-Control'].should == 'max-age=3600, public'
-    end
-  
-  end
-  
-  context 'when retrieving page' do
-    
-    it 'should retrieve the index page /' do
-      @controller.request.fullpath = '/'
-      @controller.current_site.pages.expects(:any_in).with({ :fullpath => %w{index} }).returns([@page])
-      @controller.send(:locomotive_page).should_not be_nil
-    end
-    
-    it 'should also retrieve the index page (index.html)' do
-      @controller.request.fullpath = '/index.html'
-      @controller.current_site.pages.expects(:any_in).with({ :fullpath => %w{index} }).returns([@page])
-      @controller.send(:locomotive_page).should_not be_nil
-    end
-    
-    it 'should retrieve it based on the full path' do
-      @controller.request.fullpath = '/about_us/team.html'
-      @controller.current_site.pages.expects(:any_in).with({ :fullpath => %w{about_us/team about_us/content_type_template} }).returns([@page])
-      @controller.send(:locomotive_page).should_not be_nil
-    end
-    
-    it 'should return the 404 page if the page does not exist' do
-      @controller.request.fullpath = '/contact'
-      @controller.current_site.pages.expects(:not_found).returns([true])
-      @controller.send(:locomotive_page).should be_true
-    end
-    
-    context 'templatized page' do
-      
-      before(:each) do
-        @content_type = Factory.build(:content_type, :site => nil)
-        @page.templatized = true        
-        @page.content_type = @content_type
-        @controller.request.fullpath = '/projects/edeneo.html'
-        @controller.current_site.pages.expects(:any_in).with({ :fullpath => %w{projects/edeneo projects/content_type_template} }).returns([@page])
-      end
-      
-      it 'sets the content_instance variable' do
-        @content_type.contents.stubs(:where).returns([42])
-        @controller.send(:locomotive_page).should_not be_nil
-        @controller.instance_variable_get(:@content_instance).should == 42
-      end
-      
-      it 'returns the 404 page if the instance does not exist' do
-        @content_type.contents.stubs(:where).returns([])
-        @controller.current_site.pages.expects(:not_found).returns([true])
-        @controller.send(:locomotive_page).should be_true
-        @controller.instance_variable_get(:@content_instance).should be_nil
-      end
-      
-    end
-        
-    context 'non published page' do
-      
-      before(:each) do
-        @page.published = false
-        @controller.current_admin = nil
-      end
-    
-      it 'should return the 404 page if the page has not been published yet' do
-        @controller.request.fullpath = '/contact'        
-        @controller.current_site.pages.expects(:any_in).with({ :fullpath => %w{contact content_type_template} }).returns([@page])
-        @controller.current_site.pages.expects(:not_found).returns([true])
-        @controller.send(:locomotive_page).should be_true
-      end
-      
-      it 'should not return the 404 page if the page has not been published yet and admin is logged in' do
-        @controller.current_admin = true
-        @controller.request.fullpath = '/contact'
-        @controller.current_site.pages.expects(:any_in).with({ :fullpath => %w{contact content_type_template} }).returns([@page])
-        @controller.send(:locomotive_page).should == @page
-      end
-      
-    end
-    
-  end
-  
-end

data/spec/models/account_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
- 
-describe Account do
-  
-  it 'should have a valid factory' do
-    Factory.build(:account).should be_valid
-  end
-  
-  ## Validations ##
-  
-  %w{name email password}.each do |attr|
-    it "should validate presence of #{attr}" do
-      account = Factory.build(:account, attr.to_sym => nil)
-      account.should_not be_valid
-      account.errors[attr.to_sym].should include("can't be blank")
-    end
-  end
-  
-  it "should have a default locale" do
-    account = Account.new
-    account.locale.should == 'en'
-  end
-  
-  it "should validate uniqueness of email" do
-    Factory(:account)
-    (account = Factory.build(:account)).should_not be_valid
-    account.errors[:email].should == ["is already taken"]
-  end
-  
-  ## Associations ##
-  
-  it 'should own many sites' do
-    account = Factory(:account)
-    site_1 = Factory(:site, :memberships => [Membership.new(:account => account)])
-    site_2 = Factory(:site, :subdomain => 'foo', :memberships => [Membership.new(:account => account)])
-    account.sites.should == [site_1, site_2]
-  end
-  
-  describe 'deleting' do
-    
-    before(:each) do
-      @account = Factory.build(:account)
-      @site_1 = Factory.build(:site, :subdomain => 'foo', :memberships => [Factory.build(:membership, :account => @account)])
-      @site_2 = Factory.build(:site, :subdomain => 'bar', :memberships => [Factory.build(:membership, :account => @account)])
-      @account.stubs(:sites).returns([@site_1, @site_2])
-      Site.any_instance.stubs(:save).returns(true)
-    end
-    
-    it 'should also delete memberships' do
-      Site.any_instance.stubs(:admin_memberships).returns(['junk'])
-      @account.destroy
-      @site_1.memberships.should be_empty
-      @site_2.memberships.should be_empty
-    end
-    
-    it 'should raise an exception if account is the only remaining admin' do
-      @site_1.stubs(:admin_memberships).returns(['junk'])
-      lambda {
-        @account.destroy
-      }.should raise_error(Exception, "One admin account is required at least")
-    end
-  
-  end
-  
-end