manveru-ramaze 2009.01 → 2009.04

data/spec/ramaze/controller.rb

@@ -1,180 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TCControllerController < Ramaze::Controller
-  map '/'
-  view_root 'spec/ramaze/template/ezamar'
-
-  def index
-    @text = "World"
-  end
-
-  def sum first, second
-    @num1, @num2 = first.to_i, second.to_i
-  end
-
-  def some__long__action
-  end
-
-  def another__long__action
-  end
-
-  private
-
-  def test_private
-  end
-end
-
-describe "Controller" do
-  def handle(*args)
-    Ramaze::Controller.handle(*args)
-  end
-
-  def resolve(*args)
-    Ramaze::Controller.resolve(*args)
-  end
-
-  def values(*url)
-    resolve(*url).values_at(:method, :params, :template)
-  end
-
-  ramaze :error_page => false
-  @hash = {
-    '/' => [
-      ["/", 'index', []]
-    ],
-
-    '/foo' => [
-      ["/foo", "index",      []],
-      ["/",    "foo__index", []],
-      ["/",    "foo",        []],
-      ["/",    "index",      ["foo"]]
-
-    ],
-
-    '/foo/bar' => [
-      ["/foo/bar", "index",           []],
-      ["/foo",     "bar__index",      []],
-      ["/foo",     "bar",             []],
-      ["/foo",     "index",           ["bar"]],
-      ["/",        "foo__bar__index", []],
-      ["/",        "foo__bar",        []],
-      ["/",        "foo__index",      ["bar"]],
-      ["/",        "foo",             ["bar"]],
-      ["/",        "index",           ["foo", "bar"]]
-    ],
-
-    '/foo/bar/baz' => [
-      ["/foo/bar/baz", "index",                []],
-      ["/foo/bar",     "baz__index",           []],
-      ["/foo/bar",     "baz",                  []],
-      ["/foo/bar",     "index",                ["baz"]],
-      ["/foo",         "bar__baz__index",      []],
-      ["/foo",         "bar__baz",             []],
-      ["/foo",         "bar__index",           ["baz"]],
-      ["/foo",         "bar",                  ["baz"]],
-      ["/foo",         "index",                ["bar", "baz"]],
-      ["/",            "foo__bar__baz__index", []],
-      ["/",            "foo__bar__baz",        []],
-      ["/",            "foo__bar__index",      ["baz"]],
-      ["/",            "foo__bar",             ["baz"]],
-      ["/",            "foo__index",           ["bar", "baz"]],
-      ["/",            "foo",                  ["bar", "baz"]],
-      ["/",            "index",                ["foo", "bar", "baz"]]
-    ],
-
-    '/foo/bar/baz/oof' => [
-      ["/foo/bar/baz/oof", "index",                     []],
-       ["/foo/bar/baz",     "oof__index",                []],
-       ["/foo/bar/baz",     "oof",                       []],
-       ["/foo/bar/baz",     "index",                     ["oof"]],
-       ["/foo/bar",         "baz__oof__index",           []],
-       ["/foo/bar",         "baz__oof",                  []],
-       ["/foo/bar",         "baz__index",                ["oof"]],
-       ["/foo/bar",         "baz",                       ["oof"]],
-       ["/foo/bar",         "index",                     ["baz", "oof"]],
-       ["/foo",             "bar__baz__oof__index",      []],
-       ["/foo",             "bar__baz__oof",             []],
-       ["/foo",             "bar__baz__index",           ["oof"]],
-       ["/foo",             "bar__baz",                  ["oof"]],
-       ["/foo",             "bar__index",                ["baz", "oof"]],
-       ["/foo",             "bar",                       ["baz", "oof"]],
-       ["/foo",             "index",                     ["bar", "baz", "oof"]],
-       ["/",                "foo__bar__baz__oof__index", []],
-       ["/",                "foo__bar__baz__oof",        []],
-       ["/",                "foo__bar__baz__index",      ["oof"]],
-       ["/",                "foo__bar__baz",             ["oof"]],
-       ["/",                "foo__bar__index",           ["baz", "oof"]],
-       ["/",                "foo__bar",                  ["baz", "oof"]],
-       ["/",                "foo__index",                ["bar", "baz", "oof"]],
-       ["/",                "foo",                       ["bar", "baz", "oof"]],
-       ["/",                "index",                     ["foo", "bar", "baz", "oof"]]
-    ],
-  }
-
-  it "dry patterns_for" do
-    @hash.each do |path, correct|
-      patterns = []
-      Ramaze::Controller.patterns_for(path) do |controller, action, params|
-        patterns << [controller, action, params]
-      end
-      patterns.should == correct
-    end
-  end
-
-  it '/' do
-    values('/').should ==
-      ['index', [], 'spec/ramaze/template/ezamar/index.zmr']
-  end
-
-  it '/sum/1/2' do
-    values('/sum/1/2').should ==
-      ['sum', ['1', '2'],'spec/ramaze/template/ezamar/sum.zmr']
-  end
-
-  it '/another/long/action' do
-    values('/another/long/action').should ==
-      ['another__long__action', [], 'spec/ramaze/template/ezamar/another/long/action.zmr']
-  end
-  it '/some/long/action' do
-    values('/some/long/action').should ==
-      ['some__long__action', [], 'spec/ramaze/template/ezamar/some__long__action.zmr']
-  end
-
-  it "simple request to index" do
-    handle('/').should == 'Hello, World!'
-  end
-
-  it "summing two values" do
-    handle('/sum/1/2').should == '3'
-  end
-
-  it "double underscore in templates" do
-    handle('/some/long/action').should == 'some long action'
-    handle('/another/long/action').should == 'another long action'
-    handle('/other').should == 'This is the index of /other'
-  end
-
-  TCControllerController.private_methods.sort.each do |action|
-    it action do
-      path = "/#{action}"
-      message = "No Action found for `#{path}' on TCControllerController"
-      lambda{ resolve(path) }.should.
-        raise(Ramaze::Error::NoAction).
-        message.should == message
-    end
-  end
-
-  it 'should resolve correctly even if the action is cached already.' do
-    handle('/').should == 'Hello, World!'
-    handle('/').should == 'Hello, World!'
-  end
-
-  it 'should remove invalid cached actions' do
-    handle('/').should == 'Hello, World!'
-    Ramaze::Cache.resolved['/'] = 'duh'
-    handle('/').should == 'Hello, World!'
-  end
-end

data/spec/ramaze/current/request.rb

@@ -1,30 +0,0 @@
-require 'spec/helper'
-
-describe 'Ramaze::Request' do
-  def request(env = {})
-    Ramaze::Request.new(env)
-  end
-
-  should 'provide #request_uri' do
-    request('REQUEST_URI' => '/?a=b').request_uri.should == '/?a=b'
-    request(  'PATH_INFO' => '/'    ).request_uri.should == '/'
-  end
-
-  should 'provide #local_net?' do
-    request.local_net?('192.168.0.1').to_s.should == '192.168.0.0'
-    request.local_net?('252.168.0.1').should == nil
-    request.local_net?('unknown').should == nil
-    request('REMOTE_ADDR' => '211.3.129.47, 66.249.85.131').local_net?.should == nil
-    request('REMOTE_ADDR' => '211.3.129.47').local_net?.should == nil
-  end
-
-  should 'provide #subset' do
-    params = {'a' => 'b', 'c' => 'd', 'e' => 'f'}
-    env = { 'rack.request.form_hash' => params }
-    req = request(env)
-
-    req.params.should == params
-    req.subset(:a).should == {'a' => 'b'}
-    req.subset(:a, :c).should == {'a' => 'b', 'c' => 'd'}
-  end
-end

data/spec/ramaze/current/session.rb

@@ -1,97 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TrinitySessionController < Ramaze::Controller
-  map :/
-
-  def index
-    "nothing"
-  end
-
-  def val
-    session.client[:val]
-  end
-
-  def set
-    session.client[:val] = 789
-  end
-
-  def del
-    session.client.delete(:val)
-  end
-end
-
-describe "Session" do
-  behaves_like 'http'
-  ramaze :sessions => false
-
-  it 'should work without sessions' do
-    class Ramaze::Session
-      remove_const :IP_COUNT_LIMIT
-      const_set(:IP_COUNT_LIMIT, 2)
-    end
-    (Ramaze::Session::IP_COUNT_LIMIT + 2).times do
-      r = get('/')
-      r.body.should == "nothing"
-      r.headers['Content-Type'].should == 'text/html'
-    end
-  end
-end
-
-describe "Session cookie store" do
-  behaves_like 'http'
-  ramaze :sessions => true
-
-  Ramaze::Session::SESSION_KEY.replace('sess')
-  @secret = Ramaze::Session.trait[:secret] = 'abc'
-
-  # Marshal a session hash into safe cookie data. Include an integrity hash.
-  def marshal(session)
-    data = [ Marshal.dump(session) ].pack('m').chop
-    "#{data}--#{generate_digest(data)}"
-  end
-
-  # Unmarshal cookie data to a hash and verify its integrity.
-  def unmarshal(cookie)
-    if cookie
-      data, digest = cookie.split('--')
-      return {} unless digest == generate_digest(data)
-      Marshal.load(data.unpack('m').first)
-    end
-  end
-
-  # Generate the inline SHA512 message digest. Larger (128 bytes) than SHA256
-  # (64 bytes) or RMD160 (40 bytes), but small relative to the 4096 byte
-  # max cookie size.
-  def generate_digest(data)
-    Digest::SHA512.hexdigest "#{data}#{@secret}"
-  end
-
-  it 'should use session data from cookies' do
-    r = get('/val', :cookie => "sess-client="+marshal({ :val => 123 }))
-    r.body.should == '123'
-  end
-
-  it 'should use new values from session cookie' do
-    r = get('/val', :cookie => "sess-client="+marshal({ :val => 456 }))
-    r.body.should == '456'
-  end
-
-  it 'should set session values in the cookie' do
-    r = get('/set')
-    r.headers['Set-Cookie'].should == "sess-client=#{CGI.escape(marshal({:val => 789}))}; path=/"
-  end
-
-  it 'bad cookie should be ignored' do
-    r = get('/val', :cookie => marshal({ :val => 456 }) + 'wrong')
-    r.body.should.not == '456'
-  end
-
-  it 'should allow removing the last key/value pair' do
-    r = get('/del', :cookie => "sess-client="+marshal({ :val => 456 }))
-    r.body.should == '456'
-    r.headers['Set-Cookie'].should == "sess-client=#{CGI.escape(marshal({}))}; path=/"
-  end
-end

data/spec/ramaze/dispatcher.rb

@@ -1,31 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TCDispatcherController < Ramaze::Controller
-  map '/'
-
-  def index
-    "Hello, World!"
-  end
-end
-
-describe "Dispatcher" do
-  behaves_like 'http'
-  ramaze :ignore => ['/favicon.ico', '/robots.txt'],
-    :ignore_body => 'File not found'
-
-  it 'should resolve a normal request' do
-    page = get('/')
-    page.status.should == 200
-    page.body.should == 'Hello, World!'
-  end
-
-  it 'should ignore /foo.ico' do
-    Ramaze::Global.ignore = ['/foo.ico']
-    page = get('/foo.ico')
-    page.status.should == 404
-    page.body.should == 'File not found'
-  end
-end

data/spec/ramaze/element.rb

@@ -1,107 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TCElementController < Ramaze::Controller
-  engine :Ezamar
-
-  def index
-    "The index"
-  end
-
-  def elementy
-    "<Page>#{index}</Page>"
-  end
-
-  def nested
-    "<Page> some stuff <Page>#{index}</Page> more stuff </Page>"
-  end
-
-  def with_params(*params)
-    hash = Hash[*params.flatten].map{|k,v| %{#{k}="#{v}"}}.join(' ')
-    %{<PageWithParams #{hash}></PageWithParams>}
-  end
-
-  def little
-    %{<PageLittle />}
-  end
-
-  def little_params(*params)
-    hash = Hash[*params.flatten].map{|k,v| %{#{k}="#{v}"}}.join(' ')
-    %{<PageLittleWithParams #{hash} />}
-  end
-
-  def templating(times)
-    %{<PageWithTemplating times="#{times}" />}
-  end
-end
-
-class Page < Ezamar::Element
-  def render
-    %{ <wrap> #{content} </wrap> }
-  end
-end
-
-
-class PageWithParams < Ezamar::Element
-  def render
-    ivs = (instance_variables - ['@content', :@content])
-    ivs.inject({}){|s,v| s.merge(v.to_s => instance_variable_get(v)) }.inspect
-  end
-end
-
-class PageLittle < Ezamar::Element
-  def render
-    "little"
-  end
-end
-
-class PageLittleWithParams < Ezamar::Element
-  def render
-    ivs = (instance_variables - ['@content', :@content])
-    ivs.inject({}){|s,v| s.merge(v.to_s => instance_variable_get(v)) }.inspect
-  end
-end
-
-class PageWithTemplating < Ezamar::Element
-  def render
-    (1..@times).to_a.join(', ')
-  end
-end
-
-describe "Element" do
-  ramaze(:mapping => {'/' => TCElementController})
-
-  def retrieve(*url)
-    Ramaze::Controller.handle(*url).strip
-  end
-
-  it "simple request" do
-    retrieve('/').should == "The index"
-  end
-
-  it "with element" do
-    retrieve('/elementy').should == "<wrap> The index </wrap>"
-  end
-
-  it "nested element" do
-    retrieve('/nested').should == "<wrap>  some stuff  <wrap> The index </wrap>  more stuff  </wrap>"
-  end
-
-  it "with_params" do
-    retrieve('/with_params/one/two').should == {'@one' => 'two'}.inspect
-  end
-
-  it "little" do
-    retrieve('/little').should == 'little'
-  end
-
-  it "little params" do
-    retrieve('/little_params/one/eins').should == {'@one' => 'eins'}.inspect
-  end
-
-  it "templating" do
-    retrieve('/templating/10').should == (1..10).to_a.join(', ')
-  end
-end

data/spec/ramaze/helper/aspect.rb

@@ -1,101 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-class TCAspectController < Ramaze::Controller
-  map '/'
-  trait :foo => :bar
-  helper :aspect
-
-  def test_before() $helper_aspect_spec_test_before += 2 end
-  before(:test_before){ $helper_aspect_spec_test_before = 40 }
-
-  def test_after() $helper_aspect_spec_test_after = 40 end
-  after(:test_after){ $helper_aspect_spec_test_after += 2 }
-
-  def test_wrap() end
-  wrap(:test_wrap){ $helper_aspect_spec_test_wrap ||= 0; $helper_aspect_spec_test_wrap += 21 }
-
-  wrap(:test_template) { '<aspect>' }
-end
-
-class TCAspectAllController < Ramaze::Controller
-  map '/all'
-
-  helper :aspect
-  view_root __DIR__(:view)
-
-  def test_all_first() 'first' end
-  def test_all_second() 'second' end
-
-  before_all{ $helper_aspect_spec_all = 40 }
-  after_all{ $helper_aspect_spec_all += 2 }
-
-  def test_all_after() 'after' end
-
-  def layout() '<div>#@content</div>' end
-  template :loop_with_layout, :loop
-  layout :layout => [:loop_with_layout]
-end
-
-describe "AspectHelper" do
-  behaves_like 'http'
-  ramaze :error_page => false
-
-  it "shouldn't overwrite traits on inclusion" do
-    TCAspectController.trait[:foo].should == :bar
-  end
-
-  it 'should use before' do
-    $helper_aspect_spec_test_before = nil
-    get('/test_before')
-    $helper_aspect_spec_test_before.should == 42
-  end
-
-  it 'should use after' do
-    $helper_aspect_spec_test_after = nil
-    get('/test_after')
-    $helper_aspect_spec_test_after.should == 42
-  end
-
-  it 'should use wrap' do
-    $helper_aspect_spec_test_wrap = nil
-    get('/test_wrap')
-    $helper_aspect_spec_test_wrap.should == 42
-  end
-
-  it 'should before_all and after_all' do
-    $helper_aspect_spec_all = nil
-    get('/all/test_all_first')
-    $helper_aspect_spec_all.should == 42
-
-    $helper_aspect_spec_all = nil
-    get('/all/test_all_second')
-    $helper_aspect_spec_all.should == 42
-  end
-
-  it 'should before_all and after_all for templates' do
-    $helper_aspect_spec_all = nil
-    get('/all/test_template')
-    $helper_aspect_spec_all.should == 42
-  end
-
-  it 'should before_all and after_all for all defined actions' do
-    $helper_aspect_spec_all = nil
-    get('/all/test_all_after')
-    $helper_aspect_spec_all.should == 42
-  end
-
-  it 'should not apply aspects to render_template' do
-    $helper_aspect_spec_all = nil
-    get('/all/loop').body.gsub(/\s/,'').should == '12345'
-    $helper_aspect_spec_all.should == 42
-  end
-
-  it 'should not apply aspects to layouts' do
-    $helper_aspect_spec_all = nil
-    get('/all/loop_with_layout').body.gsub(/\s/,'').should == '<div>12345</div>'
-    $helper_aspect_spec_all.should == 42
-  end
-end

data/spec/ramaze/helper/cgi.rb

@@ -1,43 +0,0 @@
-#          Copyright (c) 2006 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/cgi'
-
-class TCLink < Ramaze::Controller
-  map '/'
-end
-
-describe "url encode" do
-  extend Ramaze::Helper::CGI
-
-  it 'should url_encode strings' do
-    # ok, I believe that the web is dumb for this
-    # but this probably is a SHOULD thingy in the HTTP RFC
-    url_encode('title with spaces').should == 'title+with+spaces'
-    url_encode('[foo]').should == '%5Bfoo%5D'
-    u('//').should == '%2F%2F'
-  end
-  it 'should url_decode strings' do
-    url_decode('title%20with%20spaces').should == 'title with spaces'
-    url_decode('title+with+spaces').should == 'title with spaces'
-  end
-  it 'should be reversible' do
-    url_decode(u('../ etc/passwd')).should == '../ etc/passwd'
-  end
-end
-
-describe 'html escape' do
-  extend Ramaze::Helper::CGI
-
-  it 'should escape html' do
-    html_escape('& < >').should == '&amp; &lt; &gt;'
-    h('<&>').should == '&lt;&amp;&gt;'
-  end
-  it 'should unescape html' do
-    html_unescape('&lt; &amp; &gt;').should == '< & >'
-  end
-  it 'should be reversible' do
-    html_unescape(html_escape('2 > b && b <= 0')).should == '2 > b && b <= 0'
-  end
-end

data/spec/ramaze/helper/file.rb

@@ -1,18 +0,0 @@
-require 'spec/helper'
-
-class TCFileHelper < Ramaze::Controller
-  map '/'
-
-  def index
-    send_file(__FILE__)
-  end
-end
-
-describe 'FileHelper' do
-  behaves_like 'http'
-  ramaze
-
-  it 'serving a file' do
-    get('/').body.strip.should == File.read(__FILE__).strip
-  end
-end