merb 0.5.3 → 0.9.2

data/spec/merb/cookies_spec.rb

@@ -1,96 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module CookiesSpecModule
-  def cookie_time(time)
-    time.gmtime.strftime(Merb::Const::COOKIE_EXPIRATION_FORMAT)
-  end
-end
-
-describe Merb::Cookies do
-  include CookiesSpecModule
-
-  before do
-    @_cookies = Mash.new
-    @_headers = {}
-    @cookies = Merb::Cookies.new(@_cookies, @_headers)
-  end
-
-  it "should respond to []" do
-    @cookies.should respond_to(:[])
-  end
-
-  it "should respond to []=" do
-    @cookies.should respond_to(:[]=)
-  end
-
-  it "should respond to delete" do
-    @cookies.should respond_to(:delete)
-  end
-
-  it "should accept simple cookies that expire at end of session" do
-    @cookies[:foo] = 'bar'
-
-    @_headers['Set-Cookie'].should == ['foo=bar; path=/;']
-
-    @cookies[:foo].should == 'bar'
-    @cookies['foo'].should == 'bar'
-  end
-
-  it "should accept cookies with expiry dates" do
-    expires = Time.now + 2.weeks
-    @cookies[:dozen] = {
-      :value => 'twelve',
-      :expires => expires
-    }
-
-    @_headers['Set-Cookie'].should ==
-      ["dozen=twelve; expires=%s; path=/;" % cookie_time(expires)]
-
-    @cookies[:dozen].should == 'twelve'
-    @cookies['dozen'].should == 'twelve'
-  end
-
-  it "should accept multiple cookies" do
-    expires = Time.now + 2.weeks
-    @cookies[:foo] = 'bar'
-    @cookies[:dozen] = {
-      :value => 'twelve',
-      :expires => expires
-    }
-
-    @_headers['Set-Cookie'].should == [
-      'foo=bar; path=/;',
-      "dozen=twelve; expires=%s; path=/;" % cookie_time(expires)
-    ]
-
-    @cookies[:dozen].should == 'twelve'
-    @cookies['dozen'].should == 'twelve'
-    @cookies[:foo].should == 'bar'
-    @cookies['foo'].should == 'bar'
-  end
-
-  it "should give access to currently saved cookies" do
-    @_cookies[:original] = 'accessible'
-    @cookies[:original].should == 'accessible'
-
-    @cookies[:foo] = 'bar'
-    @cookies[:foo].should == 'bar'
-    @cookies[:original].should == 'accessible'
-  end
-
-  it "should overwrite old cookies with new cookies" do
-    @_cookies[:foo] = 'bar'
-    @cookies[:foo].should == 'bar'
-
-    @cookies[:foo] = 'new'
-    @cookies[:foo].should == 'new'
-  end
-
-  it "should allow deleting of cookies" do
-    @_cookies[:foo] = 'bar'
-    @cookies[:foo].should == 'bar'
-
-    @cookies.delete(:foo)
-    @cookies[:foo].should == nil
-  end
-end

data/spec/merb/core_ext/class_spec.rb

@@ -1,97 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,251 +0,0 @@
-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