merb-core 0.9.2 → 0.9.3

data/lib/merb-core/version.rb

@@ -1,5 +1,5 @@
 module Merb
-  VERSION = '0.9.2' unless defined?(Merb::VERSION)
+  VERSION = '0.9.3' unless defined?(Merb::VERSION)
 
   # Merb::RELEASE meanings:
   # 'dev'   : unreleased
@@ -7,5 +7,5 @@ module Merb
   #  nil    : released
   # You should never check in to trunk with this changed.  It should
   # stay 'dev'.  Change it to nil in release tags.
-  RELEASE = nil unless defined?(Merb::RELEASE)
+  RELEASE = '' unless defined?(Merb::RELEASE)
 end

data/spec/private/config/config_spec.rb

@@ -4,29 +4,29 @@ describe Merb::Config do
   before do
     Merb::Config.setup
   end
-  
+
   it "should be able to yield the configuration via #use" do
     res = nil
     Merb::Config.use {|c| res = c}
     res.should == Merb::Config.defaults
   end
-  
+
   it "should be able to get a configuration key" do
     Merb::Config[:host].should == "0.0.0.0"
   end
-  
+
   it "should be able to set a configuration key" do
     Merb::Config[:bar] = "Hello"
     Merb::Config[:bar].should == "Hello"
   end
-  
+
   it "should be able to #delete a configuration key" do
-    Merb::Config[:bar] = "Hello"    
-    Merb::Config[:bar].should == "Hello"    
+    Merb::Config[:bar] = "Hello"
+    Merb::Config[:bar].should == "Hello"
     Merb::Config.delete(:bar)
-    Merb::Config[:bar].should == nil    
+    Merb::Config[:bar].should == nil
   end
-  
+
   it "should be able to #fetch a key that does exist" do
     Merb::Config.fetch(:host, "192.168.2.1").should == "0.0.0.0"
   end
@@ -43,68 +43,96 @@ describe Merb::Config do
     Merb::Config.parse_args(["-u", "tester"])
     Merb::Config[:user].should == "tester"
   end
-  
+
   it "should support -G to set the group to run Merb as" do
     Merb::Config.parse_args(["-G", "tester"])
-    Merb::Config[:group].should == "tester"    
+    Merb::Config[:group].should == "tester"
   end
 
   it "should support -f to set the filename to run Merb as" do
     Merb::Config.parse_args(["-d"])
     Merb::Config[:daemonize].should == true
   end
-  
+
   it "should support -c to set the number of cluster nodes" do
     Merb::Config.parse_args(["-c", "4"])
     Merb::Config[:cluster].should == "4"
   end
-  
+
   it "should support -p to set the port number" do
     Merb::Config.parse_args(["-p", "6000"])
-    Merb::Config[:port].should == "6000"    
+    Merb::Config[:port].should == "6000"
   end
-  
+
   it "should support -P to set the PIDfile" do
     Merb::Config.parse_args(["-P", "pidfile"])
     Merb::Config[:pid_file].should == "pidfile"
   end
 
+  it "should have server return PIDfile setting as is with no cluster nodes" do
+    Merb::Config.parse_args(["-P", "pidfile", "-p", "6000"])
+    Merb::Server.pid_file(6000).should == "pidfile"    
+    Merb::Server.pid_files.should == ["pidfile"]
+  end
+
+  it "should support setting of PIDfile with cluster nodes" do
+    Merb::Config.parse_args(["-P", "/tmp/merb.pidfile", "-c", "2", "-p", "6000"])
+    Merb::Server.pid_file(6000).should == "/tmp/merb.6000.pidfile"
+    Merb::Server.pid_file(6001).should == "/tmp/merb.6001.pidfile"
+    
+    Dir.should_receive(:[]).with("/tmp/merb.*.pidfile")
+    Merb::Server.pid_files
+  end
+
+  it "should support default PIDfile setting" do
+    Merb::Config.parse_args(["-p", "6000"])
+    Merb::Server.pid_file(6000).should == Merb.log_path / "merb.6000.pid"
+    
+    Dir.should_receive(:[]).with(Merb.log_path / "merb.*.pid")
+    Merb::Server.pid_files
+  end
+
   it "should support -h to set the hostname" do
     Merb::Config.parse_args(["-h", "hostname"])
     Merb::Config[:host].should == "hostname"
   end
-  
+
   it "should support -i to specify loading IRB" do
     Merb::Config.parse_args(["-i"])
     Merb::Config[:adapter].should == "irb"
   end
-  
+
   it "should support -l to specify the log level" do
     Merb::Config.parse_args(["-l", "debug"])
     Merb::Config[:log_level].should == :debug
   end
-  
+
   it "should support -L to specify the location of the log file" do
     Merb::Config.parse_args(["-L", "log_file"])
     Merb::Config[:log_file].should == "log_file"
   end
-  
+
   it "should support -r to specify a runner" do
     Merb::Config.parse_args(["-r", "foo_runner"])
     Merb::Config[:runner_code].should == "foo_runner"
     Merb::Config[:adapter].should == "runner"
   end
-  
+
+  it "should support -R to specify a rackup file" do
+    Merb::Config.parse_args(["-R", "config.ru"])
+    Merb::Config[:rackup].should == "config.ru"
+  end
+
   it "should support -K for a graceful kill" do
     Merb::Server.should_receive(:kill).with("all", 1)
-    Merb::Config.parse_args(["-K", "all"])
+    Merb.start(["-K", "all"])
   end
 
   it "should support -k for a hard kill" do
     Merb::Server.should_receive(:kill).with("all", 9)
-    Merb::Config.parse_args(["-k", "all"])
+    Merb.start(["-k", "all"])
   end
-  
+
   it "should support -X off to turn off the mutex" do
     Merb::Config.parse_args(["-X", "off"])
     Merb::Config[:use_mutex].should == false
@@ -114,7 +142,7 @@ describe Merb::Config do
     Merb::Config.parse_args(["-X", "on"])
     Merb::Config[:use_mutex].should == true
   end
-  
+
   it "should take Merb.disable into account" do
     Merb::Config[:disabled_components].should == []
     Merb::Config[:disabled_components] << :foo
@@ -124,7 +152,7 @@ describe Merb::Config do
     Merb.disabled?(:foo).should == true
     Merb.disabled?(:foo, :buz).should == true
   end
-  
+
   it "should take Merb.testing? into account" do
     $TESTING.should == true
     Merb::Config[:testing].should be_nil
@@ -135,5 +163,5 @@ describe Merb::Config do
     Merb.should be_testing
     $TESTING = true; Merb::Config[:testing] = false # reset
   end
-  
-end
+
+end

data/spec/private/core_ext/class_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+class ProphecyOfSmalltalk
+end
+
+describe Class, "#reset_inheritable_attributes" do
+  it "resets @inheritable_attributes to empty Hash unless EMPTY_INHERITABLE_ATTRIBUTES constant is defined" do
+    ProphecyOfSmalltalk.reset_inheritable_attributes
+
+    ProphecyOfSmalltalk.instance_variable_get("@inheritable_attributes").should == {}
+  end
+
+  it "resets @inheritable_attributes to whatever Class::EMPTY_INHERITABLE_ATTRIBUTES is" do
+    class Class
+      EMPTY_INHERITABLE_ATTRIBUTES = { :patience => "Is a virtue" }
+    end
+
+    ProphecyOfSmalltalk.reset_inheritable_attributes
+
+    ProphecyOfSmalltalk.instance_variable_get("@inheritable_attributes")[:patience].should == "Is a virtue"
+  end
+end

data/spec/private/core_ext/hash_spec.rb

@@ -7,40 +7,43 @@ describe Hash, "environmentize_keys!" 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'} }.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, "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)
@@ -48,12 +51,13 @@ describe Hash, "to_xml_attributes" do
   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>
@@ -64,13 +68,13 @@ describe Hash, "from_xml" do
     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  
-  
+  end
+
   it "should transform repeating siblings into an array" do
     xml =<<-XML
       <opt>
@@ -78,9 +82,9 @@ describe Hash, "from_xml" do
         <user login="stty" fullname="Simon T Tyson" />
       </opt>
     XML
-    
+
     Hash.from_xml(xml)['opt']['user'].should be_an_instance_of(Array)
-    
+
     hash = {
       'opt' => {
         'user' => [{
@@ -92,57 +96,57 @@ describe Hash, "from_xml" do
         }]
       }
     }
-    
+
     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', 
+      '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"].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;",
@@ -156,43 +160,43 @@ describe Hash, "from_xml" do
       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'>
@@ -203,7 +207,7 @@ describe Hash, "from_xml" do
       <is-cool type='boolean'>true</is-cool>
     </user>
     XML
-    
+
     hash =  {
       "user" => {
         "gender"    => "m",
@@ -214,10 +218,10 @@ describe Hash, "from_xml" do
         "is_cool"   => true
       }
     }
-    
+
     Hash.from_xml(xml).should == hash
   end
-  
+
   it "should properly handle nil values (ActiveSupport Compatible)" do
     topic_xml = <<-EOT
       <topic>
@@ -232,15 +236,15 @@ describe Hash, "from_xml" do
     EOT
 
     expected_topic_hash = {
-      'title'      => nil, 
+      'title'      => nil,
       'id'         => nil,
       'approved'   => nil,
       'written_on' => nil,
       'viewed_at'  => nil,
-      'content'    => nil, 
+      'content'    => nil,
       'parent_id'  => nil
     }
-    Hash.from_xml(topic_xml)["topic"].should == expected_topic_hash 
+    Hash.from_xml(topic_xml)["topic"].should == expected_topic_hash
   end
 
   it "should handle a single record from xml (ActiveSupport Compatible)" do
@@ -362,7 +366,7 @@ describe Hash, "from_xml" do
       v.should == expected_topic_hash[k]
     end
   end
-  
+
   it "should handle an emtpy array (ActiveSupport Compatible)" do
     blog_xml = <<-XML
       <blog>
@@ -406,7 +410,7 @@ describe Hash, "from_xml" do
       </blog>
     XML
     expected_blog_hash = {"blog" => {"posts" => ["a post", "another post"]}}
-    Hash.from_xml(blog_xml).should == expected_blog_hash    
+    Hash.from_xml(blog_xml).should == expected_blog_hash
   end
 
   it "should handle file types (ActiveSupport Compatible)" do
@@ -419,10 +423,10 @@ describe Hash, "from_xml" do
     hash = Hash.from_xml(blog_xml)
     hash.should have_key('blog')
     hash['blog'].should have_key('logo')
-    
+
     file = hash['blog']['logo']
     file.original_filename.should == 'logo.png'
-    file.content_type.should == 'image/png'  
+    file.content_type.should == 'image/png'
   end
 
   it "should handle file from xml with defaults (ActiveSupport Compatible)" do
@@ -434,7 +438,7 @@ describe Hash, "from_xml" do
     XML
     file = Hash.from_xml(blog_xml)['blog']['logo']
     file.original_filename.should == 'untitled'
-    file.content_type.should == 'application/octet-stream'   
+    file.content_type.should == 'application/octet-stream'
   end
 
   it "should handle xsd like types from xml (ActiveSupport Compatible)" do
@@ -466,7 +470,7 @@ describe Hash, "from_xml" do
     <product>
       <weight type="double">0.5</weight>
       <image type="ProductImage"><filename>image.gif</filename></image>
-      
+
     </product>
     EOT
 
@@ -474,33 +478,45 @@ describe Hash, "from_xml" do
       'weight' => 0.5,
       'image' => {'type' => 'ProductImage', 'filename' => 'image.gif' },
     }
-    
+
     Hash.from_xml(product_xml)["product"].should == expected_product_hash
   end
 
   it "should handle unescaping from xml (ActiveResource Compatible)" do
     xml_string = '<person><bare-string>First &amp; Last Name</bare-string><pre-escaped-string>First &amp;amp; Last Name</pre-escaped-string></person>'
-    expected_hash = { 
-      'bare_string'        => 'First & Last Name', 
+    expected_hash = {
+      'bare_string'        => 'First & Last Name',
       'pre_escaped_string' => 'First &amp; Last Name'
     }
-    
-    Hash.from_xml(xml_string)['person'].should == expected_hash  
-  end
 
+    Hash.from_xml(xml_string)['person'].should == expected_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
+end
+
+
+describe Hash, 'to_mash' do
+  before :each do
+    @hash = Hash.new(10)
+  end
+
+  it "copies default Hash value to Mash" do
+    @mash = @hash.to_mash
+    @mash[:merb].should == 10
+  end
+end