Pistos-ramaze 2009.02 → 2009.04.08

data/spec/ramaze/helper/formatting.rb

@@ -4,7 +4,37 @@ require 'ramaze/helper/formatting'
 describe 'Helper::Formatting' do
   extend Ramaze::Helper::Formatting
 
-  it 'should format numbers' do
+  describe '#number_counter' do
+    extend Ramaze::Helper::Formatting
+
+    it 'gives a correct plural counter' do
+      number_counter(0, 'comment').should == 'no comments'
+      number_counter(1, 'comment').should == 'one comment'
+      number_counter(2, 'comment').should == 'two comments'
+      number_counter(3, 'comment').should == 'three comments'
+      number_counter(4, 'comment').should == 'four comments'
+      number_counter(5, 'comment').should == 'five comments'
+      number_counter(6, 'comment').should == 'six comments'
+      number_counter(7, 'comment').should == 'seven comments'
+      number_counter(8, 'comment').should == 'eight comments'
+      number_counter(9, 'comment').should == 'nine comments'
+      number_counter(10, 'comment').should == 'ten comments'
+      number_counter(11, 'comment').should == '11 comments'
+      number_counter(12, 'comment').should == '12 comments'
+    end
+
+    it 'uses +items+ as plural version' do
+      number_counter(0, 'pants', 'pants').should == 'no pants'
+    end
+
+    it 'tries using the pluralize method on +item+ if no +items+ given' do
+      item = 'person'
+      def item.pluralize; 'people'; end
+      number_counter(0, item).should == 'no people'
+    end
+  end
+
+  it 'formats numbers' do
     number_format(2_123_456).should == '2,123,456'
     number_format(1234.567).should == '1,234.567'
     number_format(123456.789, '.').should == '123.456,789'
@@ -12,13 +42,28 @@ describe 'Helper::Formatting' do
     number_format(132123456.789123, '.').should == '132.123.456,789123'
   end
 
-  it 'should return difference in time as a string' do
-    time_diff(Time.now-29).should == 'less than a minute'
-    time_diff(Time.now-60).should == '1 minute'
-    time_diff(Time.now, Time.now+29, true).should == 'half a minute'
+  it 'returns difference in time as a string' do
+    check = lambda{|diff, string| time_diff(Time.now - diff).should == string }
+
+    check[1, 'less than a minute']
+    check[60, '1 minute']
+    check[60 * 50, 'about 1 hour']
+    check[60 * 120, 'about 2 hours']
+    check[60 * 60 * 24, '1 day']
+    check[60 * 60 * 48, '2 days']
+    check[60 * 60 * 24 * 30, 'about 1 month']
+    check[60 * 60 * 24 * 60, '2 months']
+    check[60 * 60 * 24 * 30 * 20, 'about 1 year']
+    check[60 * 60 * 24 * 30 * 42, 'over 3 years']
+
+    time_diff(Time.now, Time.now + 4, true).should == 'less than 5 seconds'
+    time_diff(Time.now, Time.now + 6, true).should == 'less than 10 seconds'
+    time_diff(Time.now, Time.now + 29, true).should == 'half a minute'
+    time_diff(Time.now, Time.now + 50, true).should == 'less than a minute'
+    time_diff(Time.now, Time.now + 66, true).should == '1 minute'
   end
 
-  it 'should linkify urls' do
+  it 'linkifies urls' do
     auto_link("http://ramaze.net is the coolest framework, but <a href='http://merbivore.com'>merb</a> is good too").should ==
       "<a href=\"http://ramaze.net\">http://ramaze.net</a> is the coolest framework, but <a href='http://merbivore.com'>merb</a> is good too"
 
@@ -26,12 +71,12 @@ describe 'Helper::Formatting' do
       "<a href=\"http://ramaze.net\" target='_blank'>http://ramaze.net</a>"
   end
 
-  it 'should auto_link urls, setting the result of the given block as the link text' do
+  it 'auto_links urls, setting the result of the given block as the link text' do
     auto_link('http://ramaze.net rocks, so does http://rubyonrails.org.') { |url| url.sub!(%r{http://}, '') }.should ==
       '<a href="http://ramaze.net">ramaze.net</a> rocks, so does <a href="http://rubyonrails.org">rubyonrails.org</a>.'
   end
 
-  should 'ordinalize numbers' do
+  it 'ordinalizes numbers' do
     ordinal(1).should == '1st'
     ordinal(2).should == '2nd'
     ordinal(3).should == '3rd'
@@ -44,11 +89,23 @@ describe 'Helper::Formatting' do
     ordinal(133).should == '133rd'
   end
 
-  should 'generate tagclouds' do
+  it 'generates tagclouds' do
     tags = %w[ruby ruby code ramaze]
     tagcloud(tags).should ==
       {"code"=>0.75, "ramaze"=>0.75, "ruby"=>1.0}
     tagcloud(tags, 0.5, 2.0).should ==
       {"code"=>0.875, "ramaze"=>0.875, "ruby"=>1.25}
   end
+
+  it 'converts newlines to br tags' do
+    nl2br("foo\nbar\nfoobar").should == 'foo<br />bar<br />foobar'
+    nl2br("foo\nbar\nfoobar", false).should == 'foo<br>bar<br>foobar'
+  end
+
+  it 'obfuscates email addresses' do
+    obfuscate_email('foo@example.com').
+      should == "<a href=\"mailto:&#102&#111&#111&#064&#101&#120&#097&#109&#112&#108&#101&#046&#099&#111&#109\">&#102&#111&#111&#064&#101&#120&#097&#109&#112&#108&#101&#046&#099&#111&#109</a>"
+    obfuscate_email('foo@example.com', 'mail foo').
+      should == "<a href=\"mailto:&#102&#111&#111&#064&#101&#120&#097&#109&#112&#108&#101&#046&#099&#111&#109\">mail foo</a>"
+  end
 end

data/spec/ramaze/helper/gestalt.rb

@@ -0,0 +1,15 @@
+require 'spec/helper'
+require 'ramaze/helper/gestalt'
+
+describe Ramaze::Helper::Gestalt do
+  extend Ramaze::Helper::Gestalt
+
+  it 'has a shortcut for Ramaze::Gestalt::new' do
+    gestalt{ h1('title') }.to_s.should ==
+      Ramaze::Gestalt.new{ h1('title') }.to_s
+  end
+
+  it 'has a shortcut for Ramaze::Gestalt::build' do
+    build{ h1('title') }.should == '<h1>title</h1>'
+  end
+end

data/spec/ramaze/helper/gravatar.rb

@@ -0,0 +1,40 @@
+require 'spec/helper'
+require 'ramaze/helper/gravatar'
+
+describe Ramaze::Helper::Gravatar do
+  extend Ramaze::Helper::Gravatar
+
+  @email = 'ramaze-spec-gravatar@manveru.oib.com'
+  @digest = Digest::MD5.hexdigest(@email)
+
+  def uri(*tail)
+    URI("http://www.gravatar.com/avatar/#{@digest}#{tail.join}")
+  end
+
+  it 'takes an email and turns it into a hashed part of the uri' do
+    gravatar(@email).should == uri
+  end
+
+  it 'takes :size option' do
+    gravatar(@email, :size => 100).should == uri('?size=100')
+  end
+
+  it 'takes :rating option' do
+    gravatar(@email, :rating => 'g').should == uri('?rating=g')
+    gravatar(@email, :rating => 'pg').should == uri('?rating=pg')
+    gravatar(@email, :rating => 'r').should == uri('?rating=r')
+    gravatar(@email, :rating => 'x').should == uri('?rating=x')
+  end
+
+  it 'takes :default option' do
+    gravatar(@email, :default => :identicon).should == uri('?default=identicon')
+    gravatar(@email, :default => :monsterid).should == uri('?default=monsterid')
+    gravatar(@email, :default => :wavatar).should == uri('?default=wavatar')
+    gravatar(@email, :default => 'http://example.com/me.jpg').should == uri('?default=http%3A%2F%2Fexample.com%2Fme.jpg')
+  end
+
+  it 'takes :force option' do
+    gravatar(@email, :force => true).should == uri('?force=1')
+    gravatar(@email, :force => false).should == uri('')
+  end
+end

data/spec/ramaze/helper/httpdigest.rb

@@ -0,0 +1,162 @@
+require 'spec/helper'
+
+REALM = 'HttpDigestTestRealm'
+
+class MainController < Ramaze::Controller
+  map '/'
+  helper :httpdigest
+
+  def authenticate
+    user = httpdigest('protected', REALM) do |username|
+      Digest::MD5.hexdigest([username, REALM, username.reverse].join(':'))
+    end
+    "Hello #{user}"
+  end
+
+end
+
+class PlainTextController < Ramaze::Controller
+  map '/plaintext'
+  helper :httpdigest
+
+  def authenticate
+    user = httpdigest('protected', REALM)
+    "Hello #{user}"
+  end
+
+  protected
+
+  def httpdigest_lookup_plaintext_password username
+    username.reverse
+  end
+end
+
+class PasswordLookupController < Ramaze::Controller
+  map '/lookup'
+  helper :httpdigest
+
+  def authenticate
+    user = httpdigest('protected', REALM)
+    "Hello #{user}"
+  end
+
+  protected
+
+  def httpdigest_lookup_password username
+    Digest::MD5.hexdigest([username, REALM, username.reverse].join(':'))
+  end
+end
+
+describe Ramaze::Helper::HttpDigest do
+  behaves_like :mock, :session
+
+  def auth_for(got, uri, username, password, qop_type = "auth")
+    authorization = Rack::Auth::Digest::Params.parse(got.headers['WWW-Authenticate'])
+
+    cnonce = Digest::MD5.hexdigest(rand.to_s)
+    nc = 1
+    nonce = authorization['nonce']
+
+    authorization['cnonce'] = cnonce
+    authorization['nc'] = nc
+    authorization['uri'] = uri
+    authorization['username'] = username
+    authorization['qop'] = qop_type
+
+    ha1 = Digest::MD5.hexdigest([username, REALM, password].join(':'))
+    a2 = ['GET',uri]
+    a2 << Digest::MD5.hexdigest('') if qop_type == "auth-int"
+    ha2 = Digest::MD5.hexdigest( a2.join(':') )
+
+    authorization['response'] = Digest::MD5.hexdigest([ha1, nonce, nc, cnonce, qop_type, ha2].join(':'))
+
+    "Digest #{authorization}"
+  end
+
+  def get_auth( uri, username, password, qop_type = "auth" )
+    got = nil
+    session do |mock|
+      got = mock.get( uri )
+      got.status.should == 401
+      got.body.should == 'Unauthorized'
+      got = mock.get( uri , 'HTTP_AUTHORIZATION' => auth_for(got, uri, username, password, qop_type ) )
+    end
+    got
+  end
+
+  it 'sends out all the required header information' do
+    session do |mock|
+      got = mock.get('/authenticate')
+      authorization = Rack::Auth::Digest::Params.parse(got.headers['WWW-Authenticate'])
+      authorization["opaque"].should.not.be.empty
+      authorization["nonce"].should.not.be.empty
+      authorization["realm"].should == REALM
+      authorization["qop"].should == "auth,auth-int"
+      got = mock.get( '/authenticate' , 'HTTP_AUTHORIZATION' => auth_for(got, '/authenticate', 'foo', 'oof' ) )
+      got.headers.should.satisfy do |headers|
+        !headers.has_key?( "WWW-Authenticate" )
+      end
+    end
+  end
+
+  it 'authenticates a user with a block' do
+    got = get_auth( '/authenticate', 'foo', 'oof' )
+    got.status.should == 200
+    got.body.should == "Hello foo"
+  end
+
+  it 'fails to authenticate an incorrect password with a block' do
+    got = get_auth( '/authenticate', 'foo', 'bar' )
+    got.status.should == 401
+    got.body.should == "Unauthorized"
+  end
+
+  it 'authenticates a user with a block using auth for a random given' do
+    got = get_auth( '/authenticate', 'foo', 'oof', 'some-random-non-existant-auth-type' )
+    got.status.should == 200
+    got.body.should == "Hello foo"
+  end
+
+  it 'authenticates a user with the plaintext method' do
+    got = get_auth( '/plaintext/authenticate', 'foo', 'oof' )
+    got.status.should == 200
+    got.body.should == "Hello foo"
+  end
+
+  it 'fails to authenticate an incorrect password with the plaintext method' do
+    got = get_auth( '/plaintext/authenticate', 'foo', 'bar' )
+    got.status.should == 401
+    got.body.should == "Unauthorized"
+  end
+
+  it 'authenticates a user with the password lookup method' do
+    got = get_auth( '/lookup/authenticate', 'foo', 'oof' )
+    got.status.should == 200
+    got.body.should == "Hello foo"
+  end
+
+  it 'fails to authenticate an incorrect password with the password lookup method' do
+    got = get_auth( '/lookup/authenticate', 'foo', 'bar' )
+    got.status.should == 401
+    got.body.should == "Unauthorized"
+  end
+
+  it 'authenticates a user with a block using auth-int' do
+    got = get_auth( '/authenticate', 'foo', 'oof', 'auth-int' )
+    got.status.should == 200
+    got.body.should == "Hello foo"
+  end
+
+  it 'authenticates a user with the plaintext method using auth-int' do
+    got = get_auth( '/plaintext/authenticate', 'foo', 'oof', 'auth-int' )
+    got.status.should == 200
+    got.body.should == "Hello foo"
+  end
+
+  it 'authenticates a user with the password lookup method using auth-int' do
+    got = get_auth( '/lookup/authenticate', 'foo', 'oof', 'auth-int' )
+    got.status.should == 200
+    got.body.should == "Hello foo"
+  end
+
+end

data/spec/ramaze/helper/link.rb

@@ -1,124 +1,49 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'spec/helper'
 require 'ramaze/helper/link'
 
-class TCLink < Ramaze::Controller
+class SpecHelperLink < Ramaze::Controller
   map '/'
-  def index; end
 end
 
-class TCLink2 < Ramaze::Controller
-  map '/2'
-  def index; end
+class SpecHelperLinkTwo < Ramaze::Controller
+  map '/two'
 end
 
-describe "A" do
+describe Ramaze::Helper::Link do
   extend Ramaze::Helper::Link
-  behaves_like 'resolve'
 
-  ramaze
-
-  it 'should build links' do
-    A('title', :href => '/').should == %(<a href="/">title</a>)
-    A('title', :href => '/foo').should == %(<a href="/foo">title</a>)
-    A('title', :href => '/foo?x=y').should == %{<a href="/foo?x=y">title</a>}
-    stack('/'){ A('/foo?x=y') }.should == %{<a href="/foo?x=y">/foo?x=y</a>}
-
-    a = A('title', :href => '/foo', :class => :none)
-    a.should =~ /class="none"/
-    a.should =~ /href="\/foo"/
-  end
-
-  it 'should build position independend links' do
-    stack('/'){ A(TCLink, :foo) }.should == %(<a href="/foo">foo</a>)
-  end
-
-  it 'should escape path' do
-    stack('/'){ A('ti tle') }.should == '<a href="/ti+tle">ti tle</a>'
-    a = A('', :href => "/foo?chunky=b\000acon")
-    a.should == '<a href="/foo?chunky=b%00acon"></a>'
-  end
-
-  it 'should handle text key' do
-    A(:href => '/', :text => 'text').should == '<a href="/">text</a>'
-  end
-
-  it 'should use last argument as first text fallback' do
-    a = A('text', :href => '/', :title => 'title')
-    a.should =~ /href="\/"/
-    a.should =~ /title="title"/
-    a.should =~ />text</
-  end
-
-  it 'should use :title as second text fallback' do
-    a = A(:href => '/', :title => 'text')
-    a.should =~ /title="text"/
-    a.should =~ /href="\/"/
-    a.should =~ />text</
-  end
-
-  it 'should use :href as third text fallback' do
-    A(:href => '/').should == '<a href="/">/</a>'
-  end
-end
-
-describe 'R' do
-  extend Ramaze::Helper::Link
-
-  it 'should build urls' do
-    R(TCLink).should == '/'
-    R(TCLink, :foo).should == '/foo'
-    R(TCLink, :foo, :bar).should == '/foo/bar'
-    R(TCLink, :foo, :bar => :baz).should == '/foo?bar=baz'
-  end
-end
-
-describe 'Rs' do
-  extend Ramaze::Helper::Link
-
-  def resolve(url)
-    Ramaze::Controller::resolve(url)
+  it 'builds routes' do
+    R(SpecHelperLink, :foo).should == '/foo'
+    SpecHelperLink.Rs(:foo).should == '/foo'
   end
 
-  it 'should build links for current controller' do
-    resolve('/2').stack{ Rs(:index).should == '/2/index' }
-    resolve('/').stack{ Rs(:index).should == '/index' }
+  it 'builds links' do
+    SpecHelperLink.A(:foo).should == '<a href="/foo">foo</a>'
+    SpecHelperLink.A(:foo, :bar).should == '<a href="/bar">foo</a>'
   end
 
-  it 'should treat Rs() like R() when Controller given' do
-    resolve('/2').stack{ Rs(TCLink, :index).should == '/2/index' }
-  end
-
-  it 'should treat non-controllers as strings' do
-    resolve('/2').stack{ Rs(Ramaze, :index).should == '/2/Ramaze/index' }
-  end
-
-end
-
-describe 'breadcrumbs' do
-  extend Ramaze::Helper::Link
-
-  it 'should lay out breadcrumbs' do
-    breadcrumbs('/file/dir/listing/is/cool').
+  it 'lays out breadcrumbs' do
+    SpecHelperLink.breadcrumbs('/file/dir/listing/is/cool').
       should == [
-      "<a href=\"/file\">file</a>",
-      "<a href=\"/file/dir\">dir</a>",
-      "<a href=\"/file/dir/listing\">listing</a>",
-      "<a href=\"/file/dir/listing/is\">is</a>",
-      "<a href=\"/file/dir/listing/is/cool\">cool</a>"
+      '<a href="/file">file</a>',
+      '<a href="/file/dir">dir</a>',
+      '<a href="/file/dir/listing">listing</a>',
+      '<a href="/file/dir/listing/is">is</a>',
+      '<a href="/file/dir/listing/is/cool">cool</a>'
     ].join('/')
   end
 
-  it 'should lay out breadcrumbs with href prefix' do
-    breadcrumbs('/file/dir/listing/is/cool', '/', '/', '/prefix/path').
+  it 'lays out breadcrumbs with href prefix' do
+    SpecHelperLink.breadcrumbs('/file/dir/listing/is/cool', '/', '/', '/prefix/path').
       should == [
-      "<a href=\"/prefix/path/file\">file</a>",
-      "<a href=\"/prefix/path/file/dir\">dir</a>",
-      "<a href=\"/prefix/path/file/dir/listing\">listing</a>",
-      "<a href=\"/prefix/path/file/dir/listing/is\">is</a>",
-      "<a href=\"/prefix/path/file/dir/listing/is/cool\">cool</a>"
+      '<a href="/prefix/path/file">file</a>',
+      '<a href="/prefix/path/file/dir">dir</a>',
+      '<a href="/prefix/path/file/dir/listing">listing</a>',
+      '<a href="/prefix/path/file/dir/listing/is">is</a>',
+      '<a href="/prefix/path/file/dir/listing/is/cool">cool</a>'
     ].join('/')
   end
 end

data/spec/ramaze/helper/localize.rb

@@ -0,0 +1,60 @@
+# * Encoding: UTF-8
+$KCODE = 'u' if //.respond_to?(:kcode)
+require 'spec/helper'
+spec_requires 'locale/tag', 'locale'
+
+class SpecHelperLocalize < Ramaze::Controller
+  map '/'
+  helper :localize
+
+  def index
+    locale.language
+  end
+
+  def translate(string)
+    l(string)
+  end
+
+  private
+
+  def localize_dictionary
+    DICTIONARY
+  end
+end
+
+DICTIONARY = Ramaze::Helper::Localize::Dictionary.new
+DICTIONARY.load(:en, :hash => {'one' => 'one',  'two' => 'two'})
+DICTIONARY.load(:de, :hash => {'one' => 'eins', 'two' => 'zwei'})
+DICTIONARY.load(:ja, :hash => {'one' => '一', 'three' => '三'})
+
+describe Ramaze::Helper::Localize do
+  behaves_like :mock
+
+  should 'default to a language' do
+    get('/').body.should == 'en'
+  end
+
+  should 'override language by ?lang' do
+    get('/?lang=de').body.should == 'de'
+  end
+
+  should 'override language by cookie' do
+    get('/', 'HTTP_COOKIE' => 'lang=ja').body.should == 'ja'
+  end
+
+  should 'not fail if language is invalid' do
+    get('/?lang=foobar').body.should == 'foobar'
+  end
+
+  should 'use dictionary to translate' do
+    get('/translate/one').body.should == 'one'
+    get('/translate/one?lang=en').body.should == 'one'
+    get('/translate/one?lang=ja').body.should == '一'
+    get('/translate/one?lang=de').body.should == 'eins'
+  end
+
+  it "falls back to default language if string wasn't found in dictionary" do
+    get('/translate/two?lang=ja').body.should == 'two'
+    get('/translate/three?lang=ja').body.should == '三'
+  end
+end

data/spec/ramaze/helper/maruku.rb

@@ -0,0 +1,19 @@
+require 'spec/helper'
+spec_require 'maruku'
+
+class SpecHelperMaruku < Ramaze::Controller
+  map '/'
+  helper :maruku
+
+  def index
+    maruku('# Hello')
+  end
+end
+
+describe Ramaze::Helper::Maruku do
+  behaves_like :mock
+
+  it 'converts a markdown string to html' do
+    get('/').body.should =~ /<h1 id=["']hello["']>Hello<\/h1>/
+  end
+end

data/spec/ramaze/helper/pager.rb

@@ -1,8 +1,7 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'spec/helper'
-
 spec_require 'hpricot'
 
 module Og
@@ -27,16 +26,12 @@ class TCPagerController < Ramaze::Controller
 
     items.inspect
   end
-
 end
 
 shared 'pager' do
-  behaves_like 'http'
-  behaves_like 'resolve'
+  behaves_like :mock
   extend Ramaze::Helper::Pager
 
-  ramaze
-
   def pager_key
     Ramaze::Pager.trait[:key]
   end
@@ -56,27 +51,29 @@ shared 'pager' do
 
   it 'should be paginated' do
     get('/page').body.should == [1, 2].inspect
-    get('/page', pager_key => '2').body.should == [3, 4].inspect
+    get('/page?_page=2').body.should == [3, 4].inspect
   end
 
   it "should report the number of articles as Pager#total_count" do
-    @pager.should.not.be.nil
     @pager.total_count.should.equal 5
   end
 
   it "should return the same number of items as passed to :per_page" do
-    @items.should.not.be.nil
     @items.size.should.equal 2
   end
 
   it "should link to other pages" do
-    stack('/page') do
-      @pager.should.not.be.nil
-      @pager.navigation.should.not.be.nil
+    # mock the action
+    action = '/page'
+    def action.node; TCPagerController; end
+    def action.name; self; end
+    Ramaze::Current.actions = [action]
 
-      page = Hpricot(@pager.navigation)
-      (page / 'a').size.should == 4
-    end
+    @pager.should.not.be.nil
+    @pager.navigation.should.not.be.nil
+
+    page = Hpricot(@pager.navigation)
+    (page / 'a').size.should == 4
   end
 end