merb 0.4.2 → 0.5.0

data/spec/fixtures/controllers/render_spec_controllers.rb

@@ -38,8 +38,8 @@ class FakeModelWithArguments
   end
   
   def to_xml(*args)
-    options = args.last.is_a?(Hash) ? args.pop.stringify_keys : {}
-    options.keys.sort.inject('') do |str, tag|
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    options.keys.sort_by{|s| s.to_s}.inject('') do |str, tag|
       str << "<#{tag}>#{options[tag]}</#{tag}>"
     end
   end
@@ -169,6 +169,6 @@ class ExtensionTemplateController < Merb::Controller
 
 end
 
-Merb::Server.load_action_arguments
-Merb::Server.load_controller_template_path_cache
-Merb::Server.load_erubis_inline_helpers
+Merb::BootLoader.load_action_arguments
+Merb::BootLoader.load_controller_template_path_cache
+Merb::BootLoader.load_inline_helpers

data/spec/fixtures/models/router_spec_models.rb

@@ -18,3 +18,13 @@ class Comment
     42
   end  
 end
+
+
+class Blog
+  def id
+    42
+  end
+  def to_param
+    "hello#{id}"
+  end
+end    

data/spec/merb/abstract_controller_spec.rb

@@ -13,8 +13,8 @@ describe Merb::AbstractController do
   end
   
   after(:all) do
-    Merb::Server.load_controller_template_path_cache
-    Merb::Server.load_erubis_inline_helpers    
+    Merb::BootLoader.load_controller_template_path_cache
+    Merb::BootLoader.load_inline_helpers    
   end
   
   it "should add a template path" do

data/spec/merb/assets_spec.rb

@@ -0,0 +1,207 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require "fileutils"
+
+describe Merb::Assets, "in the production environment" do
+  
+  before(:each) do
+    @old_env = Merb::Config[:environment]
+    Merb::Config[:environment] = :production
+    Merb::Config.delete(:bundle_assets)
+  end
+  
+  after(:each) do
+    Merb::Config[:environment] = @old_env
+  end
+  
+  it "should bundle assets" do
+    Merb::Assets.bundle?.should == true
+  end
+  
+end
+
+describe Merb::Assets, "in the development environment" do
+  
+  before(:each) do
+    @old_env = Merb::Config[:environment]
+    Merb::Config[:environment] = :development
+    Merb::Config.delete(:bundle_assets)
+  end
+  
+  after(:each) do
+    Merb::Config[:environment] = @old_env
+  end
+  
+  it "should not bundle assets" do
+    Merb::Assets.bundle?.should == false
+  end
+  
+end
+
+describe Merb::Assets, "in the development environment with asset bundling enabled" do
+  
+  before(:each) do
+    @old_env = Merb::Config[:environment]
+    Merb::Config[:environment] = :development
+    Merb::Config[:bundle_assets] = true
+  end
+  
+  after(:each) do
+    Merb::Config[:environment] = @old_env
+  end
+  
+  it "should bundle assets" do
+    Merb::Assets.bundle?.should == true
+  end
+  
+end
+
+describe Merb::Assets::AssetHelpers, "asset_path" do
+  
+  include Merb::Assets::AssetHelpers
+  
+  it "should turn a symbol shorthand for a javascript asset into a URI path" do
+    asset_path(:javascript, :dingo).should == "/javascripts/dingo.js"
+  end
+  
+  it "should turn a string shorthand for a javascript asset into a URI path" do
+    asset_path(:javascript, "dingo").should == "/javascripts/dingo.js"
+    asset_path(:javascript, "dingo.r7337").should == "/javascripts/dingo.r7337.js"
+    asset_path(:javascript, "dingo/wakka").should == "/javascripts/dingo/wakka.js"
+  end
+  
+  it "should turn the filename of a javascript asset into a URI path" do
+    asset_path(:javascript, "dingo.js").should == "/javascripts/dingo.js"
+  end
+  
+  it "should turn a symbol shorthand for a stylesheet asset into a URI path" do
+    asset_path(:stylesheet, :dingo).should == "/stylesheets/dingo.css"
+  end
+  
+  it "should turn a string shorthand for a stylesheet asset into a URI path" do
+    asset_path(:stylesheet, "dingo").should == "/stylesheets/dingo.css"
+    asset_path(:stylesheet, "dingo.r7337").should == "/stylesheets/dingo.r7337.css"
+    asset_path(:stylesheet, "dingo/wakka").should == "/stylesheets/dingo/wakka.css"
+  end
+  
+  it "should turn the filename of a stylesheet asset into a URI path" do
+    asset_path(:stylesheet, "dingo.css").should == "/stylesheets/dingo.css"
+  end
+  
+  it "should turn an asset name into a file path" do
+    asset_path(:stylesheet, :dingo, true).should == "public/stylesheets/dingo.css"
+  end
+  
+  it "should prepend any path prefix to a URI path" do
+    begin
+      Merb::Config[:path_prefix] = '/inky'
+      asset_path(:stylesheet, "dingo.css").should == "/inky/stylesheets/dingo.css"
+    ensure
+      Merb::Config.delete(:path_prefix)
+    end
+  end
+  
+  it "should prepend any path prefix to a local path" do
+    begin
+      Merb::Config[:path_prefix] = '/inky'
+      asset_path(:stylesheet, "dingo.css", true).should == "public/stylesheets/dingo.css"
+    ensure
+      Merb::Config.delete(:path_prefix)
+    end
+  end
+end
+
+describe "an asset bundler with callbacks", :shared => true do
+  it "should collect callbacks for execution after bundling" do
+    @bundler_klass.add_callback { |filename| "yay #{filename}" }
+    @bundler_klass.callbacks.should have(1).procs
+    @bundler_klass.callbacks.first.call("me").should == "yay me"
+    @bundler_klass.callbacks.clear
+  end
+end
+
+describe "an asset bundler", :shared => true do
+  
+  include Merb::Assets::AssetHelpers
+  
+  before(:each) do
+    FileUtils.mkdir_p("./public/#{@bundler_klass.asset_type}s")
+    create_fixture_files
+  end
+  
+  after(:each) do
+    FileUtils.rm_rf("./public")
+  end
+  
+  def create_fixture_files
+    @asset1 = :asset1
+    @asset1filename = asset_path(@bundler_klass.asset_type, @asset1, true)
+    File.open(@asset1filename, "w") { |f| f << "one" }
+    
+    @asset2 = :asset2
+    @asset2filename = asset_path(@bundler_klass.asset_type, @asset2, true)
+    File.open(@asset2filename, "w") { |f| f << "two" }
+    
+    @asset3 = :asset3
+    @asset3filename = asset_path(@bundler_klass.asset_type, @asset3, true)
+    File.open(@asset3filename, "w") { |f| f << "three" }
+  end
+  
+  it "should combine files into a single file" do
+    bundler = @bundler_klass.new(true, @asset1, @asset2, @asset3)
+    bundle_name = bundler.bundle!
+    File.read(asset_path(@bundler_klass.asset_type, bundle_name, true)).should == "one\ntwo\nthree\n"
+  end
+  
+  it "should not overwrite bundles" do
+    File.open(asset_path(@bundler_klass.asset_type, :all, true), "w") { |f| f << "exists" }
+    bundler = @bundler_klass.new(true, @asset1, @asset2, @asset3)
+    bundle_name = bundler.bundle!
+    File.read(asset_path(@bundler_klass.asset_type, bundle_name, true)).should == "exists"
+  end
+  
+  it "should execute all callbacks, passing them the bundled file's path" do
+    begin
+      @bundler_klass.add_callback do |filename|
+        File.open(filename, "a") do |f|
+          f.puts "yay"
+        end
+      end
+      
+      bundler = @bundler_klass.new(true, @asset1, @asset2, @asset3)
+      bundle_name = bundler.bundle!
+      File.read(asset_path(@bundler_klass.asset_type, bundle_name, true)).should == "one\ntwo\nthree\nyay\n"
+    ensure
+      @bundler_klass.callbacks.clear
+    end
+  end
+  
+end
+
+describe Merb::Assets::JavascriptAssetBundler do
+  
+  before(:each) do
+    @bundler_klass = Merb::Assets::JavascriptAssetBundler
+  end
+  
+  it "should handle javascript assets" do
+    @bundler_klass.asset_type.should == :javascript
+  end
+  
+  it_should_behave_like "an asset bundler"
+  it_should_behave_like "an asset bundler with callbacks"
+end
+
+describe Merb::Assets::StylesheetAssetBundler do
+  
+  before(:each) do
+    @bundler_klass = Merb::Assets::StylesheetAssetBundler
+  end
+  
+  it "should handle stylesheet assets" do
+    @bundler_klass.asset_type.should == :stylesheet
+  end
+  
+  it_should_behave_like "an asset bundler"
+  it_should_behave_like "an asset bundler with callbacks"
+end

data/spec/merb/caching_spec.rb

@@ -83,7 +83,7 @@ end
 
 describe "fragment caching in memory" do
   before do
-    Merb::Server.config['cache_store'] = 'memory'
+    Merb::Config['cache_store'] = 'memory'
     @c = Merb::Caching::Fragment
     @c.clear
   end
@@ -93,7 +93,7 @@ end
 
 describe "fragment caching to a file" do
   before do
-    Merb::Server.config[:cache_store] = 'file'
+    Merb::Config[:cache_store] = 'file'
     @c = Merb::Caching::Fragment
     @c.clear
   end

data/spec/merb/controller_spec.rb

@@ -13,11 +13,16 @@ describe "Merb::Controller" do
     c = new_controller
     c._layout.should == :application
   end
-  
+
   it "should have a spec helper to dispatch that skips the router" do
     Merb::Router.should_not_receive(:match)
     dispatch_to(Bar, :foo, :id => "1") do |controller|
-      controller.should_receive(:foo).with("1")
+      if defined? ParseTreeArray # We have parameterized actions
+        controller.should_receive(:foo).with("1")
+      else
+        controller.should_receive(:foo) # No parameterized actions
+        controller.params[:id].should == "1"
+      end
     end
   end
   

data/spec/merb/cookie_store_spec.rb

@@ -18,7 +18,7 @@ class TestCookieSessionController < Merb::Controller
   
 end
 
-Merb::Server.config[:session_secret_key] = 'Secret!'
+Merb::Config[:session_secret_key] = 'Secret!'
 
 describe Merb::SessionMixin do
   it "should set the cookie if the cookie is changed" do

data/spec/merb/core_ext/class_spec.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+# Class cattr_reader
+
+class ClassWithCAttrReader
+  cattr_reader      :bacon
+  def initialize;   @@bacon = "chunky";   end
+end
+
+describe "Core Class with cattr_reader", :shared => true do
+
+  it "should read value from attribute" do
+    @klass.bacon.should == "chunky"
+  end
+
+  it "should not write to attribute" do
+    lambda {
+      @klass.bacon = "soggy"
+    }.should raise_error(NoMethodError)
+  end
+
+end
+
+describe Class, "with cattr_reader" do
+
+  before do
+    @klass = ClassWithCAttrReader.new.class
+  end
+  it_should_behave_like "Core Class with cattr_reader"
+
+end
+
+describe Class, "with cattr_reader (instantiated)" do
+
+  before do
+    @klass = ClassWithCAttrReader.new
+  end
+  it_should_behave_like "Core Class with cattr_reader"
+
+end
+
+# Class cattr_writer
+
+class ClassWithCAttrWriter
+  cattr_writer      :bacon
+  def self.chunky?; @@bacon == "chunky";  end
+  def chunky?;      self.class.chunky?;   end
+end
+
+describe "Core Class with cattr_writer", :shared => true do
+
+  it "should write value to attribute" do
+    @klass.should be_chunky
+  end
+
+  it "should not read attribute" do
+    lambda {
+      @klass.bacon
+    }.should raise_error(NoMethodError)
+  end
+
+end
+
+describe Class, "with cattr_writer" do
+
+  before do
+    @klass = ClassWithCAttrWriter.new.class
+    @klass.bacon = "chunky"
+  end
+  it_should_behave_like "Core Class with cattr_writer"
+
+end
+
+describe Class, "with cattr_writer (instantiated)" do
+
+  before do
+    @klass = ClassWithCAttrWriter.new
+    @klass.bacon = "chunky"
+  end
+  it_should_behave_like "Core Class with cattr_writer"
+
+end
+
+class ClassWithAttrInitialize
+  attr_initialize :dog, :muppet
+  attr_accessor   :dog, :muppet
+end
+
+describe ClassWithAttrInitialize do
+
+  it "should initialize with values" do
+    c = ClassWithAttrInitialize.new("louie", "bert")
+    c.dog.should    == "louie"
+    c.muppet.should == "bert"
+  end
+
+end

data/spec/merb/core_ext/enumerable_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Enumerable do
+  before do
+    @mascots = ['louie', 'bert', 'ernie']
+  end
+  
+  it "should perform injecting" do
+    @mascots.injecting({}) { |m,i| m[i] = i.size }.should == 
+         { 'louie' => 5, 'bert' => 4, 'ernie' => 5 }
+  end
+  
+  it "should find arrays of things inside other arrays" do
+    @mascots.include_any?('louie', 'sasquatch').should be_true
+  end
+  
+  it "should recognize absence of arrays of things inside other arrays" do
+    @mascots.include_any?('chicken', 'sasquatch').should be_false
+  end
+  
+  it "should group by" do
+    groups = (1..6).group_by{ |i| i % 3 }
+    groups[0].should == [3,6]
+    groups[1].should == [1,4]
+    groups[2].should == [2,5]
+  end
+end

data/spec/merb/core_ext/hash_spec.rb

@@ -0,0 +1,251 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Hash, "environmentize_keys!" do
+  it "should transform keys to uppercase text" do
+    { :test_1  => 'test', 'test_2' => 'test', 1 => 'test' }.environmentize_keys!.should ==
+      { 'TEST_1' => 'test', 'TEST_2' => 'test', '1' => 'test' }
+  end
+  
+  it "should only transform one level of keys" do
+    { :test_1  => { :test2 => 'test'} }.environmentize_keys!.should == 
+      { 'TEST_1' => { :test2 => 'test'} }
+  end
+end
+
+describe Hash, "only" do
+  before do
+    @hash = { :one => 'ONE', 'two' => 'TWO', 3 => 'THREE' }
+  end
+  
+  it "should return a hash with only the given key(s)" do
+    @hash.only(:one).should == { :one => 'ONE' }
+    @hash.only(:one, 3).should == { :one => 'ONE', 3 => 'THREE' }
+  end
+end
+
+describe Hash, "except" do
+  before do
+    @hash = { :one => 'ONE', 'two' => 'TWO', 3 => 'THREE' }
+  end
+  
+  it "should return a hash without only the given key(s)" do
+    @hash.except(:one).should == { 'two' => 'TWO', 3 => 'THREE' }
+    @hash.except(:one, 3).should == { 'two' => 'TWO' }
+  end
+end
+
+describe Hash, "symbolize_keys!" do
+  before do
+    @hash = { 'one' => 1, 'two' => 2 }
+    @hash_with_another_hash = { 'a' => 'A', 'prefs' => { 'private' => true, 'sex' => 'yes please' } }
+    @hash_with_non_string_keys = { 'one' => 1, 2 => 'TWO', '' => 'blank' }
+  end
+  
+  it "should convert all keys to symbols" do
+    @hash.symbolize_keys!
+    @hash.should == { :one => 1, :two => 2 }
+  end
+  
+  it "should recursively convert all keys to symbols" do
+    @hash_with_another_hash.symbolize_keys!
+    @hash_with_another_hash.should == { :a => 'A', :prefs => { :private => true, :sex => 'yes please' } }
+  end
+end
+
+describe Hash, "to_xml_attributes" do
+  before do
+    @hash = { :one => "ONE", "two" => "TWO" }
+  end
+  
+  it "should turn the hash into xml attributes" do
+    attrs = @hash.to_xml_attributes
+    attrs.should match(/one="ONE"/m)
+    attrs.should match(/two="TWO"/m)
+  end
+end
+
+describe Hash, "from_xml" do
+  it "should transform a simple tag with content" do
+    xml = "<tag>This is the contents</tag>"
+    Hash.from_xml(xml).should == { 'tag' => 'This is the contents' }
+  end
+  
+  it "should work with cdata tags" do
+    xml = <<-END
+      <tag>
+      <![CDATA[
+        text inside cdata
+      ]]>
+      </tag>
+    END
+    Hash.from_xml(xml)["tag"].strip.should == "text inside cdata"
+  end
+  
+  it "should transform a simple tag with attributes" do
+    xml = "<tag attr1='1' attr2='2'></tag>"
+    hash = { 'tag' => { 'attr1' => '1', 'attr2' => '2' } }
+    Hash.from_xml(xml).should == hash
+  end  
+  
+  it "should transform repeating siblings into an array" do
+    xml =<<-XML
+      <opt>
+        <user login="grep" fullname="Gary R Epstein" />
+        <user login="stty" fullname="Simon T Tyson" />
+      </opt>
+    XML
+    
+    Hash.from_xml(xml)['opt']['user'].should be_an_instance_of(Array)
+    
+    hash = {
+      'opt' => {
+        'user' => [{
+          'login'    => 'grep',
+          'fullname' => 'Gary R Epstein'
+        },{
+          'login'    => 'stty',
+          'fullname' => 'Simon T Tyson'
+        }]
+      }
+    }
+    
+    Hash.from_xml(xml).should == hash
+  end
+  
+  it "should not transform non-repeating siblings into an array" do
+    xml =<<-XML
+      <opt>
+        <user login="grep" fullname="Gary R Epstein" />
+      </opt>
+    XML
+      
+    Hash.from_xml(xml)['opt']['user'].should be_an_instance_of(Hash)
+    
+    hash = {
+      'opt' => { 
+        'user' => { 
+          'login' => 'grep', 
+          'fullname' => 'Gary R Epstein'
+        }
+      }
+    }
+    
+    Hash.from_xml(xml).should == hash
+  end
+  
+  it "should typecast an integer" do
+    xml = "<tag type='integer'>10</tag>"
+    Hash.from_xml(xml)['tag'].should == 10
+  end
+  
+  it "should typecast a true boolean" do
+    xml = "<tag type='boolean'>true</tag>"
+    Hash.from_xml(xml)['tag'].should be_true
+  end
+  
+  it "should typecast a false boolean" do
+    ["false", "1", "0", "some word" ].each do |w|
+      Hash.from_xml("<tag type='boolean'>#{w}</tag>")['tag'].should be_false
+    end
+  end
+  
+  it "should typecast a datetime" do
+    xml = "<tag type='datetime'>2007-12-31 10:32</tag>"
+    Hash.from_xml(xml)['tag'].should == Time.parse( '2007-12-31 10:32' ).utc
+  end
+  
+  it "should typecast a date" do
+    xml = "<tag type='date'>2007-12-31</tag>"
+    Hash.from_xml(xml)['tag'].should == Date.parse('2007-12-31')
+  end
+  
+  it "should unescape html entities" do
+    values = {
+      "<" => "&lt;",
+      ">" => "&gt;",
+      '"' => "&quot;",
+      "'" => "&apos;",
+      "&" => "&amp;"
+    }
+    values.each do |k,v|
+      xml = "<tag>Some content #{v}</tag>"
+      Hash.from_xml(xml)['tag'].should match(Regexp.new(k))
+    end
+  end
+  
+  it "should undasherize keys as tags" do
+    xml = "<tag-1>Stuff</tag-1>"
+    Hash.from_xml(xml).keys.should include( 'tag_1' )
+  end
+  
+  it "should undasherize keys as attributes" do
+    xml = "<tag1 attr-1='1'></tag1>"
+    Hash.from_xml(xml)['tag1'].keys.should include( 'attr_1')
+  end
+  
+  it "should undasherize keys as tags and attributes" do
+    xml = "<tag-1 attr-1='1'></tag-1>"
+    Hash.from_xml(xml).keys.should include( 'tag_1' )
+    Hash.from_xml(xml)['tag_1'].keys.should include( 'attr_1')
+  end
+  
+  it "should render nested content correctly" do
+    xml = "<root><tag1>Tag1 Content <em><strong>This is strong</strong></em></tag1></root>"
+    Hash.from_xml(xml)['root']['tag1'].should == "Tag1 Content <em><strong>This is strong</strong></em>"
+  end
+  
+  it "should render nested content with split text nodes correctly" do
+    xml = "<root>Tag1 Content<em>Stuff</em> Hi There</root>"
+    Hash.from_xml(xml)['root'].should == "Tag1 Content<em>Stuff</em> Hi There"
+  end
+  
+  it "should ignore attributes when a child is a text node" do
+    xml = "<root attr1='1'>Stuff</root>"
+    Hash.from_xml(xml).should == { "root" => "Stuff" }
+  end
+  
+  it "should ignore attributes when any child is a text node" do
+    xml = "<root attr1='1'>Stuff <em>in italics</em></root>"
+    Hash.from_xml(xml).should == { "root" => "Stuff <em>in italics</em>" }
+  end
+  
+  it "should correctly transform multiple children" do
+    xml = <<-XML
+    <user gender='m'>
+      <age type='integer'>35</age>
+      <name>Home Simpson</name>
+      <dob type='date'>1988-01-01</dob>
+      <joined-at type='datetime'>2000-04-28 23:01</joined-at>
+      <is-cool type='boolean'>true</is-cool>
+    </user>
+    XML
+    
+    hash =  {
+      "user" => {
+        "gender"    => "m",
+        "age"       => 35,
+        "name"      => "Home Simpson",
+        "dob"       => Date.parse('1988-01-01'),
+        "joined_at" => Time.parse("2000-04-28 23:01"),
+        "is_cool"   => true
+      }
+    }
+    
+    Hash.from_xml(xml).should == hash
+  end
+end
+
+describe Hash, 'to_params' do
+  before do
+    @hash = { :name => 'Bob', :address => { :street => '111 Ruby Ave.', :city => 'Ruby Central', :phones => ['111-111-1111', '222-222-2222'] } }
+  end
+  
+  it 'should convert correctly into query parameters' do
+    @hash.to_params.split('&').sort.should ==
+      'name=Bob&address[city]=Ruby Central&address[phones]=111-111-1111222-222-2222&address[street]=111 Ruby Ave.'.split('&').sort
+  end
+  
+  it 'should not leave a trailing &' do
+    @hash.to_params.should_not match(/&$/)
+  end
+end