merb 0.5.3 → 0.9.2

data/spec/merb/server_spec.rb

@@ -1,19 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Merb::Config do
-  it "should apply environment from the command line option --environment" do
-    options = Merb::Config.parse_args(["--environment", "performance_testing"])
-    options[:environment].should == "performance_testing"
-  end
-
-  it "should apply environment from the command line option -e" do
-    options = Merb::Config.parse_args(["-e", "selenium"])
-    options[:environment].should == "selenium"
-  end
-  
-  it "should load the yaml file for the environment if it exists" do
-    options = Merb::Config.parse_args(["-e", "environment_config_test"])
-    options[:loaded_config_for_environment_config_test].should == true
-  end
-  
-end

data/spec/merb/template_spec.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Merb::Template do
-  
-  it "should register the extensions for a given engine" do
-    Merb::Template::EXTENSIONS["tester_ext"].should be_nil
-    Merb::Template::EXTENSIONS["ext"].should be_nil
-    Merb::Template.register_extensions(:tester, %w[tester_ext ext])
-    Merb::Template::EXTENSIONS["tester_ext"].should == :tester
-    Merb::Template::EXTENSIONS["ext"].should == :tester
-  end
-  
-  it "should raise an error when registering extensions if the engine is not a symbol" do
-    lambda do
-      Merb::Template.register_extensions("tester", %w(thing))
-    end.should raise_error(ArgumentError)
-  end
-  
-  it "should raise an error when registering extensions if the extensions are not an array" do
-    lambda do
-      Merb::Template.register_extensions(:tester, "tester")
-    end.should raise_error(ArgumentError)
-  end
-  
-  it "should select the engine for an erubis file" do
-    Merb::Template.engine_for("test.html.erb").should == Merb::Template::Erubis
-  end
-  
-  it "should select the engine for an haml file" do
-    Merb::Template.engine_for("test.html.haml").should == Merb::Template::Haml
-  end
-  
-  it "should select the engine for a markaby file" do
-    Merb::Template.engine_for("test.html.mab").should == Merb::Template::Markaby    
-  end
-  
-  it "should select the builder engine" do
-    Merb::Template.engine_for("test.xml.builder").should == Merb::Template::XMLBuilder    
-  end
-  
-end

data/spec/merb/upload_handler_spec.rb

@@ -1,108 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe MerbUploadHandler do
-  before(:each) do
-    @progress = mock(:upload_progress)
-    @progress.stub!(:debug)
-    @progress.stub!(:update_checked_time)
-    @progress.stub!(:add)
-    @progress.stub!(:mark)
-    @progress.stub!(:finish)
-    @progress.stub!(:last_checked).and_return Time.now - 10
-    Merb::UploadProgress.stub!(:new).and_return(@progress)
-    @handler   = MerbUploadHandler.new(:upload_frequency => 3, :upload_path_match => '^/files/\d+')
-    @upload_id = '880b7835-8a67-400e-a8f1-dec18691d604'
-    @params    = {
-      'CONTENT_LENGTH' => "10",
-      'PATH_INFO' => '/files/23',
-      'REQUEST_METHOD' => 'POST',
-      'QUERY_STRING' => "upload_id=#{@upload_id}"
-    }
-    @request  = mock(:request)
-    @request.stub!(:params).and_return(@params)
-    @response = mock(:response)
-  end
-  
-  after(:each) do
-    Mongrel.class_eval do
-      remove_const :Uploads
-    end
-  end
-  
-  it "should consider requests as invalid if the path regex does not match" do
-    @handler.send(:valid_upload?, {
-      'CONTENT_LENGTH' => "10",
-      'PATH_INFO' => '/spoons/',
-      'REQUEST_METHOD' => 'POST',
-      'QUERY_STRING' => "upload_id=#{@upload_id}"
-    }).should == nil
-  end
-  
-  it "should send a message to Mongrel::Uploads when calling upload_notify" do
-    Mongrel::Uploads.should_receive(:add)
-    @handler.send(:upload_notify, :add, @params)
-  end
-  
-  it "should receive upload_notify with :add when the request begins" do
-    @handler.should_receive(:upload_notify).with(:add, @params, 10)
-    @handler.request_begins(@params)
-  end
-  
-  it "should receive upload_notify with :mark when progress is checked" do
-    @handler.should_receive(:upload_notify).with(:mark, @params, 7)
-    @handler.request_progress(@params, 7, 10)
-  end
-  
-  it "should receive upload_notify with :finish when ready to process the request" do
-    @handler.should_receive(:upload_notify).with(:finish, @params)
-    @handler.process(@request,@response)
-  end
-  
-  it "should send Mongrel::Uploads :finish if the request is a valid upload" do
-    Mongrel::Uploads.should_receive(:finish).with(@upload_id)
-    @handler.stub!(:valid_upload?).and_return(@upload_id)
-    @handler.request_aborted(@params)
-  end
-  
-  it 'should log info about aborted requests' do
-    @handler.stub!(:valid_upload?).and_return(@upload_id)
-    Mongrel::Uploads.should_receive(:finish).with(@upload_id)
-    Merb.logger.should_receive :info
-    @handler.request_aborted(@params)
-  end
-  
-  it "should not send Mongrel::Uploads :finish unless the request is a valid upload" do
-    Mongrel::Uploads.should_not_receive(:finish)
-    @handler.stub!(:valid_upload?).and_return(false)
-    @handler.request_aborted(@params)
-  end
-  
-  it "should return an upload_id for a valid upload" do
-    @handler.send(:valid_upload?, @params).should == @upload_id
-  end
-  
-  it "should not consider a GET a valid upload" do
-    @params['REQUEST_METHOD'] = 'GET'
-    @handler.send(:valid_upload?, @params).should be_false
-  end
-  
-  it "should consider a PUT a valid upload" do
-    @params['REQUEST_METHOD'] = 'PUT'
-    @handler.send(:valid_upload?, @params).should == @upload_id
-  end
-  
-  it "should update Mongrel::Uploads' last checked time when calling upload_notify" do
-    Mongrel::Uploads.should_receive(:update_checked_time).with(@upload_id)
-    @handler.send(:upload_notify, :add, @params)
-  end
-  
-  it "should not update Mongrel::Uploads' last checked time when calling upload_notify if the action is :finish" do
-    Mongrel::Uploads.should_not_receive(:update_checked_time)
-    @handler.send(:upload_notify, :finish, @params)
-  end
-  
-  it "should not allow progress checks more frequently than the specified frequency" do
-    Mongrel::Uploads.update_checked_time(@upload_id)
-    @handler.request_progress(@params,7,10).should be_nil
-  end
-end

data/spec/merb/version_spec.rb

@@ -1,33 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe 'Merb version.rb svn revision methods' do
-  it 'should give a path to a file containing the svn revision' do
-    Merb.svn_revision_file_path.should ==
-      File.expand_path(File.join(Dir.pwd, Merb.svn_revision_filename))
-  end
-  
-  it "should create the #{Merb.svn_revision_filename} file if it does not exist" do
-    File.delete Merb.svn_revision_file_path
-    Merb.svn_revision_from_file
-    File.file?(Merb.svn_revision_file_path).should == true
-  end
-  
-  it 'should not raise permissions error' do
-    File.should_receive(:open).and_raise(Errno::EACCES)
-    Merb.svn_revision_from_file.should_not raise_error(Errno::EACCES)
-  end
-  
-  it 'should get the svn revision' do
-    Merb.svn_revision.should > 0
-  end
-  
-  it "should get the svn revision from the #{Merb.svn_revision_filename} file" do
-    Merb.svn_revision_from_file.should > 0
-  end
-  
-  it 'should get the same number from the helper and the file' do
-    Merb.svn_revision.should == Merb.svn_revision_from_file
-  end
-  
-  it 'should get the svn revision via git'
-end

data/spec/merb/view_context_spec.rb

@@ -1,366 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require_fixtures '/controllers/render_spec_controllers'
-
-describe "View Context", "image tag" do
-
-  include Merb::ViewContextMixin
-  it "should render a link" do
-    tag = link_to("NAME", "http://example.com", :title => "TITLE", :target => "TARGET")
-    tag.should match_tag(:a, :href => "http://example.com",
-                             :title => "TITLE",
-                             :target => "TARGET",
-                             :content => "NAME")
-  end
-
-  it "should render local image" do
-    tag = image_tag('foo.gif')
-    tag.should match_tag(:img, :src => "/images/foo.gif")
-  end
-
-  it "should render a local image with a path_prefix" do
-    Merb::Config[:path_prefix] = '/inky'
-
-    tag = image_tag('foo.gif')
-    tag.should match_tag(:img, :src => "/inky/images/foo.gif")
-
-    Merb::Config.delete(:path_prefix)
-  end
-
-  it "should render local image with class" do
-    tag = image_tag('foo.gif', :class => 'bar')
-    tag.should match_tag(:img, :src => "/images/foo.gif", :class => "bar")
-  end
-
-  it "should render local image with class and explicit path" do
-    tag = image_tag('foo.gif', :class => 'bar', :path => '/files/')
-    tag.should match_tag(:img, :src => "/files/foo.gif", :class => "bar")
-  end
-
-  it "should render remote image" do
-    tag = image_tag('http://test.com/foo.gif')
-    tag.should match_tag(:img, :src => "http://test.com/foo.gif")
-  end
-
-  it "should render remote SSL image" do
-    tag = image_tag('https://test.com/foo.gif')
-    tag.should match_tag(:img, :src => "https://test.com/foo.gif")
-  end
-
-end
-
-describe "View Context", "css tag" do
-
-  include Merb::ViewContextMixin
-
-  it "should render a link tag with the css_include_tag method" do
-    tag = css_include_tag('foo.css')
-    tag.should match_tag(:link, :href => "/stylesheets/foo.css",
-                                :media => "all",
-                                :rel => "Stylesheet",
-                                :type => "text/css",
-                                :content => nil)
-
-    css_include_tag('foo').should == css_include_tag('foo.css')
-    css_include_tag('foo', 'bar').should ==
-      css_include_tag('foo') + css_include_tag('bar')
-  end
-  
-  it "should alter the 'media' attribute based on the provided options" do
-    tag = css_include_tag('foo.css', :media => :screen)
-    tag.should match_tag(:link, :href => "/stylesheets/foo.css",
-                                :media => "screen",
-                                :rel => "Stylesheet",
-                                :type => "text/css",
-                                :content => nil)
-  end
-
-  it "should render a link tag with a path_prefix" do
-    Merb::Config[:path_prefix] = '/inky'
-
-    tag = css_include_tag('foo.css')
-    tag.should match_tag(:link, :href => "/inky/stylesheets/foo.css",
-                                :media => "all",
-                                :rel => "Stylesheet",
-                                :type => "text/css",
-                                :content => nil)
-
-    Merb::Config.delete(:path_prefix)
-  end
-
-  it "should not generate a script tag with the include_required_css" do
-    include_required_css.clean.should == ''
-  end
-
-  it "should generate script tags with the include_required_css" do
-    require_css('foo')
-    require_css('bar')
-    include_required_css.should == css_include_tag('foo') + css_include_tag('bar')
-  end
-end
-
-describe "View Context", "css tag with bundles" do
-
-  include Merb::ViewContextMixin
-  
-  before(:each) do
-    @bundler = mock(:bundler)
-    Merb::Assets.stub!(:bundle?).and_return(true)
-    Merb::Assets::StylesheetAssetBundler.stub!(:new).and_return(@bundler)
-    @bundler.stub!(:bundle!).and_return(:all)
-  end
-  
-  it "should not bundle stylesheets if asset bundling is disabled" do
-    Merb::Assets.should_receive(:bundle?).and_return(false)
-    
-    tag = css_include_tag(:fonts, :colors, :bundle => true)
-    tag.should == css_include_tag(:fonts) + css_include_tag(:colors)
-  end
-  
-  it "should not bundle stylesheets if only a single stylesheet was provided" do
-    css_include_tag(:fonts, :bundle => true).should == css_include_tag(:fonts)
-  end
-  
-  it "should bundle all stylesheets as 'all.css' if no bundle name is provided" do
-    Merb::Assets.should_receive(:bundle?).and_return(true)
-    Merb::Assets::StylesheetAssetBundler.should_receive(:new).with(true, :fonts, :colors).and_return(@bundler)
-    @bundler.should_receive(:bundle!).and_return(:all)
-    
-    tag = css_include_tag(:fonts, :colors, :bundle => true)
-    tag.should match_tag(:link, :href => "/stylesheets/all.css",
-                                :media => "all",
-                                :rel => "Stylesheet",
-                                :type => "text/css",
-                                :content => nil)
-  end
-  
-  it "should bundle all stylesheets whatever bundle name is provided" do
-    Merb::Assets.should_receive(:bundle?).and_return(true)
-    Merb::Assets::StylesheetAssetBundler.should_receive(:new).with(:base, :fonts, :colors).and_return(@bundler)
-    @bundler.should_receive(:bundle!).and_return(:base)
-    
-    tag = css_include_tag(:fonts, :colors, :bundle => :base)
-    tag.should match_tag(:link, :href => "/stylesheets/base.css",
-                                :media => "all",
-                                :rel => "Stylesheet",
-                                :type => "text/css",
-                                :content => nil)
-  end
-  
-  it "should not generate a stylesheet tag with the include_required_css" do
-    include_required_css(:bundle => true).clean.should == ''
-  end
-
-  it "should generate stylesheet tags with the include_required_css" do
-    Merb::Assets.should_receive(:bundle?).and_return(true)
-    Merb::Assets::StylesheetAssetBundler.should_receive(:new).with(true, :fonts, :colors).and_return(@bundler)
-    @bundler.should_receive(:bundle!).and_return(:all)
-    
-    require_css(:fonts)
-    require_css(:colors)
-    tag = include_required_css(:bundle => true)
-    
-    tag.should match_tag(:link, :href => "/stylesheets/all.css",
-                                :media => "all",
-                                :rel => "Stylesheet",
-                                :type => "text/css",
-                                :content => nil)
-  end
-end
-
-describe "View Context", "script tag" do
-
-  include Merb::ViewContextMixin
-
-  it "should render a script tag with the js_include_tag method" do
-    tag = js_include_tag('foo.js')
-    tag.should match_tag(:script, :src => "/javascripts/foo.js",
-                                  :type => "text/javascript",
-                                  :content => "//")
-
-    js_include_tag('foo').should == js_include_tag('foo.js')
-    js_include_tag('foo', 'bar').should ==
-      js_include_tag('foo') + js_include_tag('bar')
-  end
-
-  it "should render a script tag with a path_prefix" do
-    Merb::Config[:path_prefix] = '/inky'
-
-    tag = js_include_tag('foo.js')
-    tag.should match_tag(:script, :src => "/inky/javascripts/foo.js",
-                                  :type => "text/javascript",
-                                  :content => "//")
-
-    Merb::Config.delete(:path_prefix)
-  end
-
-  it "should not generate a script tag with the include_required_js" do
-    include_required_js.clean.should == ''
-  end
-
-  it "should generate script tags with the include_required_js" do
-    require_js('foo')
-    require_js('bar')
-    include_required_js.should == js_include_tag('foo') + js_include_tag('bar')
-  end
-end
-
-describe "View Context", "script tag with bundles" do
-
-  include Merb::ViewContextMixin
-  
-  before(:each) do
-    @bundler = mock(:bundler)
-    Merb::Assets.stub!(:bundle?).and_return(true)
-    Merb::Assets::JavascriptAssetBundler.stub!(:new).and_return(@bundler)
-    @bundler.stub!(:bundle!).and_return(:all)
-  end
-  
-  it "should not bundle scripts if asset bundling is disabled" do
-    Merb::Assets.should_receive(:bundle?).and_return(false)
-    
-    tag = js_include_tag(:prototype, :lowpro, :bundle => true)
-    tag.should == js_include_tag(:prototype) + js_include_tag(:lowpro)
-  end
-  
-  it "should not bundle scripts if only a single script was provided" do
-    css_include_tag(:prototype, :bundle => true).should == css_include_tag(:prototype)
-  end
-  
-  it "should bundle all scripts as 'all.js' if no bundle name is provided" do
-    Merb::Assets.should_receive(:bundle?).and_return(true)
-    Merb::Assets::JavascriptAssetBundler.should_receive(:new).with(true, :prototype, :lowpro).and_return(@bundler)
-    @bundler.should_receive(:bundle!).and_return(:all)
-    
-    tag = js_include_tag(:prototype, :lowpro, :bundle => true)
-    tag.should match_tag(:script, :src => "/javascripts/all.js",
-                                  :type => "text/javascript",
-                                  :content => "//")
-  end
-  
-  it "should bundle all stylesheets whatever bundle name is provided" do
-    Merb::Assets.should_receive(:bundle?).and_return(true)
-    Merb::Assets::JavascriptAssetBundler.should_receive(:new).with(:base, :prototype, :lowpro).and_return(@bundler)
-    @bundler.should_receive(:bundle!).and_return(:base)
-
-    tag = js_include_tag(:prototype, :lowpro, :bundle => :base)
-    tag.should match_tag(:script, :src => "/javascripts/base.js",
-                                  :type => "text/javascript",
-                                  :content => "//")
-  end
-  
-  it "should not generate a script tag with the include_required_js" do
-    include_required_js(:bundle => true).clean.should == ''
-  end
-
-  it "should generate script tags with the include_required_js" do
-    Merb::Assets.should_receive(:bundle?).and_return(true)
-    Merb::Assets::JavascriptAssetBundler.should_receive(:new).with(true, :prototype, :lowpro).and_return(@bundler)
-    @bundler.should_receive(:bundle!).and_return(:all)
-    
-    require_js(:prototype)
-    require_js(:lowpro)
-    
-    tag = include_required_js(:bundle => true)
-    tag.should match_tag(:script, :src => "/javascripts/all.js",
-                                  :type => "text/javascript",
-                                  :content => "//")
-  end
-end
-
-describe "View Context", "throw_content, catch_content" do
-
-  include Merb::ViewContextMixin
-
-  it "should throw content" do
-    c = new_controller
-    content = c.render :template => "examples/template_throw_content", :layout => :none
-    content.should match( /THROWN CONTENT/m )
-  end
-
-  it "should throw content including a partial" do
-    c = new_controller
-    content = c.render :template => "examples/template_catch_content_from_partial", :layout => :none
-    content.should match( /CONTENT THROWN FROM PARTIAL/m )
-  end
-
-  it "should catch content" do
-    c = new_controller
-    content = c.render :template => "examples/template_catch_content", :layout => :none
-    content.should match( /CAUGHT CONTENT/m)
-  end
-
-  it "should catch content with multiple throws" do
-    c = new_controller
-    content = c.render :template => "examples/template_catch_content", :layout => :none
-    content.should match( /CAUGHT FOOTER/m )
-    content.should match( /START FOOTER\s+CAUGHT FOOTER\s+END FOOTER/m )
-  end
-
-  it "should not render the block inline" do
-    c = new_controller
-    content = c.render :template => "examples/template_catch_content", :layout => :none
-    content.should match( /\A\s*START HEADER\s*CAUGHT CONTENT\s*END HEADER\s*START FOOTER\s*CAUGHT FOOTER\s*END FOOTER\s*\Z/m)
-  end
-
-  it "should throw content as an argument without a block" do
-    c = new_controller
-    content = c.render :template => "examples/template_throw_content_without_block", :layout => :none
-    content.should match(/Content Without Block/)
-  end
-end
-
-describe Merb::ViewContextMixin do
-  # The use of this here is to avoid conflict with the tag()
-  # Hpricot test helper invoked via match_tag() when testing the 
-  # tag() view context helper.
-  class FakeViewContext
-    include Merb::ErubisCaptureMixin, Merb::ViewContextMixin
-  end
-  
-  before :each do
-    @view = FakeViewContext.new
-  end
-  
-  it "should render the start of a tag" do
-    @view.open_tag(:div).should match_tag(:div)
-  end
-  
-  it "should render the start of a tag with attributes" do
-    @view.open_tag(:div, :id => 1, :class => "CLASS").
-      should match_tag(:div, :id => "1", :class => "CLASS")
-  end
-  
-  it "should render a self closing tag" do
-    @view.self_closing_tag(:br).should match_tag(:br)
-  end
-  
-  it "should render a self closing tag with attributes" do
-    @view.self_closing_tag(:img, :src => "SOURCE").
-      should match_tag(:img, :src => "SOURCE")
-  end
-  
-  it "should render a closing tag" do
-    @view.close_tag(:div).should == "</div>"
-  end
-  
-  it 'should render a tag with content' do
-    @view.tag(:div, 'divs rool').should match_tag(:div, :content => 'divs rool')
-  end
-  
-  it 'should render a tag with content and attributes' do
-    @view.tag(:div, 'divs rool', :class => 'classy').
-      should match_tag(:div, :content => 'divs rool', :class => 'classy')
-  end
-  
-  it 'should render a tag using a block for its contents' do
-    @view.tag(:div) do
-      'divs rool'
-    end.should match_tag(:div, :content => 'divs rool')
-  end
-  
-  it 'should render a tag with attributes using a block for its contents' do
-    @view.tag(:div, :class => 'classy') do
-      'divs rool'
-    end.should match_tag(:div, :content => 'divs rool', :class => 'classy')
-  end
-end