ramaze 0.3.9.1 → 2023.01.06

data/spec/examples/templates/template_amrita2.rb

@@ -1,16 +0,0 @@
-require 'spec/helper'
-
-spec_require 'amrita2'
-require 'examples/templates/template_amrita2'
-
-describe 'Template Amrita2' do
-  behaves_like 'http'
-  ramaze
-
-  it '/external' do
-    html = get('/external').body
-    html.should.not == nil
-    html.should =~ %r{<title>Template::Amrita2 external</title>}
-    html.should =~ %r{<h1>The external Template for Amrita2</h1>}
-  end
-end

data/spec/examples/templates/template_redcloth.rb

@@ -1,28 +0,0 @@
-require 'spec/helper'
-
-spec_require 'redcloth'
-spec_require 'examples/templates/template_redcloth'
-
-describe 'Template RedCloth' do
-  behaves_like 'http'
-  ramaze
-
-  it '/' do
-    html = get('/').body.strip
-    html.should =~ %r(<a href=\"/\">Home</a>)
-    html.should =~ %r(<a href=\"/internal\">internal</a>)
-    html.should =~ %r(<a href=\"/external\">external</a>)
-  end
-
-  %w[/internal /external].each do |url|
-    it url do
-      name = url.gsub(/^\//, '')
-      response = get(url)
-      response.status.should == 200
-      html = response.body
-      html.should.not == nil
-      html.should =~ %r(<title>Template::RedCloth #{name}</title>)
-      html.should =~ %r(<h1>The #{name} Template for RedCloth</h1>)
-    end
-  end
-end

data/spec/ramaze/action/basics.rb

@@ -1,36 +0,0 @@
-require 'spec/helper'
-
-describe 'Action() basics' do
-  it 'should have useful defaults' do
-    action = Ramaze::Action()
-
-    action.params.should == []
-    action.method.should == nil
-    action.template.should == nil
-  end
-
-  it 'should sanitize parameters' do
-    action = Ramaze::Action :params => [[1],[2],nil,'%20'],
-                            :method => :foo
-
-    action.params.should == ['1', '2', ' ']
-    action.method.should == 'foo'
-  end
-
-  it 'should be transformable in an hash' do
-    # we need to supply a :controller because internal accessor methods
-    # will use it to build some defaults.
-    # TODO: in Action.new() raise on init :controller or use a default
-    hsh = Ramaze::Action(:controller=>Object).to_hash
-    hsh[:method].should == nil
-    hsh[:binding].should.instance_of?(Binding)
-    hsh[:controller].should == Object
-    hsh[:engine].should == Ramaze::Template::Ezamar
-    hsh[:params].should == []
-    hsh[:path].should == nil
-    hsh[:instance].should.instance_of?(Object)
-    hsh[:template].should == nil
-  end
-
-
-end

data/spec/ramaze/action/cache.rb

@@ -1,43 +0,0 @@
-require 'spec/helper'
-
-class TCActionCache < Ramaze::Controller
-  map '/'
-  helper :cache
-
-  def index
-    rand
-  end
-  cache :index
-end
-
-class TCOtherCache < Ramaze::Controller
-  map '/other'
-  helper :cache
-
-  def index
-    rand
-  end
-  cache :index
-end
-
-describe 'Action rendering' do
-  behaves_like 'http'
-
-  @public_root = __DIR__ / :public
-  FileUtils.mkdir_p @public_root
-  ramaze :file_cache => true
-
-  def req(path) r = get(path); [r.content_type, r.body] end
-
-  it 'should cache to file' do
-    lambda{ req('/') }.should.not.change{ req('/') }
-    File.file?(@public_root/'index').should == true
-  end
-
-  it 'should create subdirs as needed' do
-    lambda{ req('/other') }.should.not.change{ req('/other') }
-    File.file?(@public_root/'other'/'index').should == true
-  end
-
-  FileUtils.rm_rf @public_root
-end

data/spec/ramaze/action/layout.rb

@@ -1,190 +0,0 @@
-require 'spec/helper'
-
-class TCActionLayout < Ramaze::Controller
-  map '/'
-  layout '/wrapper'
-
-  def wrapper
-    "<pre>#@content</pre>"
-  end
-
-  def index
-    'Hello, World!'
-  end
-
-  def foo
-    "bar"
-  end
-end
-
-class TCActionOtherLayout < Ramaze::Controller
-  map '/other'
-  layout '/other_wrapper'
-  template_root __DIR__/:template
-
-  def index
-    "Others Hello"
-  end
-end
-
-class TCActionSingleLayout < Ramaze::Controller
-  map '/single'
-  layout '/single_wrapper' => :index
-
-  def index
-    "Single Hello"
-  end
-
-  def without
-    "Without wrapper"
-  end
-end
-
-class TCActionDenyLayout < Ramaze::Controller
-  map '/deny'
-  layout '/single_wrapper'
-  deny_layout :without
-
-  def index
-    "Single Hello"
-  end
-
-  def without
-    "Without wrapper"
-  end
-end
-
-class TCActionMultiLayout < Ramaze::Controller
-  map '/multi'
-  layout '/single_wrapper' => [:index, :second]
-
-  def index
-    "Single Hello"
-  end
-
-  def second
-    "Second with layout"
-  end
-
-  def without
-    "Without wrapper"
-  end
-end
-
-class TCActionSubLayout < Ramaze::Controller
-  map '/sub'
-  layout :sub_wrapper
-
-  def index
-    "Sub Hello"
-  end
-end
-
-class TCReUseActionLayout < Ramaze::Controller
-  map '/reuse'
-  layout '/wrapper'
-
-  def index
-    'hi'
-  end
-
-  def other_layout
-    "#@title: #@content"
-  end
-end
-
-class TCLayoutInstance < Ramaze::Controller
-  map '/reuse_instance'
-  layout '/reuse/other_layout'
-
-  def index
-    @title = 'hello'
-    'world'
-  end
-end
-
-class TCLayoutInstanceVars < Ramaze::Controller
-  map '/instancevars'
-  layout :layout
-
-  def layout
-    @title = "layout"
-  end
-
-  def test
-    'test'
-  end
-end
-
-class TCActionTwoLevelLayout < Ramaze::Controller
-  map '/twolevel'
-  layout :wrapper
-  layout :wrapper2 => [:foo]
-
-  def wrapper
-    "<pre>#@content</pre>"
-  end
-
-  def wrapper2
-    "<code>#@content</code>"
-  end
-
-  def index
-    'Hello, World!'
-  end
-
-  def foo
-    "bar"
-  end
-end
-
-describe 'Action rendering' do
-  behaves_like 'http'
-  ramaze
-
-  it 'should work with layouts' do
-    get('/').body.should == "<pre>Hello, World!</pre>"
-    get('/foo').body.should == "<pre>bar</pre>"
-    get('/bar').body.should == "<pre>Hello from bar</pre>"
-  end
-
-  it 'should work with layout from file' do
-    get('/other').body.should == "<p>Others Hello</p>"
-    get('/other/bar').body.should == "<p>Hello from bar</p>"
-  end
-
-  it 'should apply single layout' do
-    get('/single').body.should == "<b>Single Hello</b>"
-    get('/single/without').body.should == "Without wrapper"
-  end
-
-  it 'should deny a single action' do
-    get('/deny').body.should == "<b>Single Hello</b>"
-    get('/deny/without').body.should == "Without wrapper"
-  end
-
-  it 'should apply layout to a list of actions' do
-    get('/multi').body.should == "<b>Single Hello</b>"
-    get('/multi/second').body.should == "<b>Second with layout</b>"
-    get('/multi/without').body.should == "Without wrapper"
-  end
-
-  it 'should apply relative layouts' do
-    get('/sub').body.should == "<h1>SubWrapper</h1>"
-  end
-
-  it 'should use instance vars defined in the layout action in external templates' do
-    get('/instancevars/test').body.should == 'layout: test'
-  end
-
-  it 'should allow re-using layouts from other controllers' do
-    get('/reuse').body.should == "<pre>hi</pre>"
-    get('/reuse_instance').body.should == "hello: world"
-  end
-
-  it 'should be able to override :all' do
-    get('/twolevel/index').body.should == '<pre>Hello, World!</pre>'
-    get('/twolevel/foo').body.should == '<code>bar</code>'
-  end
-
-end

data/spec/ramaze/adapter/mongrel.rb

@@ -1,12 +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'
-
-spec_require 'mongrel'
-
-def ramaze_options
-  { :adapter => :mongrel }
-end
-
-require 'spec/ramaze/adapter'

data/spec/ramaze/adapter/record.rb

@@ -1,31 +0,0 @@
-require 'spec/helper'
-
-class TCRecordController < Ramaze::Controller
-  map '/'
-
-  def index
-    'The index'
-  end
-
-  def foo
-    'The foo'
-  end
-end
-
-describe 'Adapter recording' do
-  behaves_like 'http'
-
-  ramaze :adapter => :webrick, :record => lambda{|request|
-    request.remote_addr == '127.0.0.1'
-  }
-
-  @record = Ramaze::Record
-
-  it 'should record' do
-    get('/').body.should == 'The index'
-    get('/foo').body.should == 'The foo'
-    @record.size.should == 2
-    @record.first.path_info.should == '/'
-    @record.last.path_info.should == '/foo'
-  end
-end

data/spec/ramaze/adapter/webrick.rb

@@ -1,12 +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'
-
-spec_require 'webrick'
-
-def ramaze_options
-  { :adapter => :webrick }
-end
-
-require 'spec/ramaze/adapter'

data/spec/ramaze/adapter.rb

@@ -1,22 +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 TCAdapterController < Ramaze::Controller
-  map '/'
-
-  def index
-    "The index"
-  end
-end
-
-ramaze ramaze_options.merge(:spawn => 10)
-
-describe "Adapter" do
-  behaves_like "http"
-
-  it 'should do a simple request' do
-    get('/').body.should == 'The index'
-  end
-end

data/spec/ramaze/cache.rb

@@ -1,73 +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'
-
-caches = {:memory => 'Hash', :yaml => 'Ramaze::YAMLStoreCache'}
-
-begin
-  require 'memcache'
-  caches[:memcached] = 'Ramaze::MemcachedCache'
-rescue LoadError
-  puts "skipping memcached"
-end
-
-caches.each do |cache, name|
-  describe "#{name} setup" do
-    it "should be assignable to Global" do
-      Ramaze::Global.cache = cache
-      Ramaze::Global.cache.to_s.should == name
-    end
-
-    it "should do .new" do
-      @cache = Ramaze::Global.cache.new
-      @cache.class.name.should == name
-    end
-  end
-
-  describe "#{name} modification" do
-    before do
-      Ramaze::Global.cache = cache
-      @cache = Ramaze::Global.cache.new
-    end
-
-    after do
-      @cache.clear
-    end
-
-    it "should be assignable with #[]=" do
-      @cache[:foo] = :bar
-      @cache[:foo].should == :bar
-    end
-
-    it "should be retrievable with #[]" do
-      @cache[:yoh] = :bar
-      @cache[:yoh].should == :bar
-    end
-
-    it "should delete keys" do
-      @cache[:bar] = :duh
-      @cache.delete(:bar)
-      @cache[:bar].should == nil
-    end
-
-    it "should show values for multiple keys" do
-      @cache[:baz] = :foo
-      @cache[:beh] = :feh
-      @cache.values_at(:baz, :beh).should == [:foo, :feh]
-    end
-
-    it "different cache namespaces should not overlap" do
-      Ramaze::Cache.add :foo
-      Ramaze::Cache.add :bar
-
-      key = "foobar"
-      Ramaze::Cache.foo[key] = 'foo'
-      Ramaze::Cache.bar[key] = 'bar'
-
-      Ramaze::Cache.foo[key].should.not == Ramaze::Cache.bar[key]
-    end
-
-    FileUtils.rm(@cache.file) if cache == :yaml
-  end
-end

data/spec/ramaze/controller.rb

@@ -1,177 +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 '/'
-  template_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 pattern_for" do
-    @hash.each do |path, correct|
-      patterns = Ramaze::Controller.pattern_for(path)
-      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