ramaze 2009.03 → 2009.04

data/spec/ramaze/controller/actionless_templates.rb

@@ -1,15 +1,21 @@
-#          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'
 
-class MainController < Ramaze::Controller
-  template :non_existant_method, :list
+Ramaze::App.options.merge!(:layouts => 'view')
+
+class SpecActionlessTemplates < Ramaze::Controller
+  map '/'
+  trait :needs_method => true
+  alias_view :non_existant_method, :list
 end
 
-class TCActionOtherLayout < Ramaze::Controller
+class SpecActionlessTemplatesLayout < Ramaze::Controller
   map '/other'
-  layout '/other_wrapper'
+  layout 'other_wrapper'
+  map_layouts '/'
+  trait :needs_method => true
 
   def index
     "Others Hello"
@@ -17,16 +23,14 @@ class TCActionOtherLayout < Ramaze::Controller
 end
 
 describe "Testing Actionless Templates" do
-  behaves_like 'http'
-  ramaze :actionless_templates => false,
-         :view_root => __DIR__(:view), :error_page => true
+  behaves_like :mock
 
   it "should not find template file for non existant method" do
+    get('/list').status.should == 404
     get('/non_existant_method').status.should == 404
-    get('/non_existant_method2').status.should == 404
   end
 
   it "should render layout(without method) for normal action" do
-    get('/other/index').body.should == '<p>Others Hello</p>'
+    get('/other').body.should == '<p>Others Hello</p>'
   end
 end

data/spec/ramaze/controller/mapping.rb

@@ -0,0 +1,57 @@
+require 'spec/helper'
+
+describe 'Controller::generate_mapping' do
+  def gen(klass)
+    Ramaze::Controller::generate_mapping(klass)
+  end
+
+  it 'maps ::ClassController to /class' do
+    gen('ClassController').should == '/class'
+  end
+
+  it 'maps ::CamelCaseController to /camel_case' do
+    gen('CamelCaseController').should == '/camel_case'
+  end
+
+  it 'maps Module::ClassController to /module/class' do
+    gen('Module::ClassController').should == '/module/class'
+  end
+
+  it 'maps Class to /class' do
+    gen('Class').should == '/class'
+  end
+
+  it 'maps Module::Class to /module/class' do
+    gen('Module::Class').should == '/module/class'
+  end
+
+  it 'maps Module::Module::Class to module/module/class' do
+    gen('Module::Module::Class').should == '/module/module/class'
+  end
+
+  it "maps MainController to '/'" do
+    gen('MainController').should == '/'
+  end
+
+  it "doesn't map ::Controller" do
+    gen('Controller').should == nil
+  end
+
+  it "doesn't map anonymous classes" do
+    gen(Class.new.name).should == nil
+  end
+end
+
+class SpecControllerMapping < Ramaze::Controller
+  def index
+    'automatically mapped'
+  end
+end
+
+describe 'Controller automap' do
+  behaves_like :mock
+
+  it 'automatically creates an app and maps the controller into it' do
+    get('/spec_controller_mapping').body.should == 'automatically mapped'
+  end
+end

data/spec/ramaze/controller/provide_inheritance.rb

@@ -0,0 +1,47 @@
+require 'spec/helper'
+
+class SpecControllerInheritedMain < Ramaze::Controller
+  Ramaze.node('/')
+
+  def index
+    @ngr = "Main is nagoro"
+    "<p>#{@ngr}</p>"
+  end
+end
+
+class SpecControllerInheritedOther < Ramaze::Controller
+  Ramaze.node('/other').engine(:Haml)
+  def index; "%p Other is haml"; end
+end
+
+class SpecControllerInheritedAnother < SpecControllerInheritedOther
+  Ramaze.node('/another')
+  def index; "%p Another is haml. Inherit from Other"; end
+end
+
+class SpecControllerInheritedYetAnother < SpecControllerInheritedAnother
+  Ramaze.node('/yet_another').engine(:Maruku)
+  def index; "Yet Another is Maruku. Inherited but overriden"; end
+end
+
+describe 'Ramaze::Controller#self.inherited' do
+  behaves_like :mock
+
+  should 'default renders nagoro' do
+    get('/').body.should == "<p>Main is nagoro</p>"
+  end
+
+  should 'be able to render provided format' do
+    get('/other').body.should == "<p>Other is haml</p>\n"
+  end
+
+  should "inherit provide from parent controller" do
+    get('/another').body.should ==
+      "<p>Another is haml. Inherit from Other</p>\n"
+  end
+
+  should "be able to override inherited provide" do
+    get('/yet_another').body.should ==
+      "<p>Yet Another is Maruku. Inherited but overriden</p>"
+  end
+end

data/spec/ramaze/controller/resolve.rb

@@ -1,21 +1,19 @@
-#          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'
 
 class MainController < Ramaze::Controller
-  engine :None
+  map '/'
 
-  define_method('file.ext') { 'file.ext' }
-  define_method('css/file.css') { 'file.css' }
-  define_method(:path/:to/:js/'file.js') { 'file.js' }
-
-  define_method(:other/:greet/:other) { @greet = 'hi' }
+  define_method('file.ext'){ 'file.ext' }
+  define_method('css__file.css'){ 'file.css' }
+  define_method('path__to__js__file.js'){ 'file.js' }
+  define_method('other__greet__other'){ @greet = 'hi' }
 end
 
 describe 'Controller resolving' do
-  behaves_like 'http'
-  ramaze :view_root => __DIR__(:view)
+  behaves_like :mock
 
   it 'should work with .' do
     get('/file.ext').body.should == 'file.ext'

data/spec/ramaze/controller/subclass.rb

@@ -1,36 +1,36 @@
-#          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'
 
 class BaseController < Ramaze::Controller
-  template :foo, :bar
-  template :one, self, :another
+  alias_view :foo, :bar
+  alias_view :one, :another, self
 
   def test() 'test' end
 end
 
 class MainController < BaseController
-  engine :None
 end
 
 describe 'Controller' do
-  behaves_like 'http'
-  ramaze
+  behaves_like :mock
 
-  it 'should allow sub-classing MainController' do
+  it 'allows sub-classing MainController' do
     get('/test').body.should == 'test'
   end
 
-  it 'should respect template mappings set in superclass, with no explicit controller' do
-    # The template file it should use is view/bar.xhtml, as the template mapping doesn't
-    # specify a controller, so it will be implicitly relative to MainController.
+  it 'respects view aliase from superclass, with no explicit controller' do
+    # The template file it should use is view/bar.xhtml, as the template
+    # mapping doesn't specify a controller, so it will be implicitly relative
+    # to MainController.
     get('/foo').body.should == 'bar'
   end
 
-  it 'should respect template mappings set in superclass, with an explicit controller' do
-    # Note that the template file it should use is view/base/another.xhtml, because
-    # BaseController explicitly specifies the template mapping in relation to self.
+  it 'respects view aliase from superclass, with an explicit controller' do
+    # Note that the template file it should use is view/base/another.xhtml,
+    # because BaseController explicitly specifies the template mapping in
+    # relation to self.
     get('/one').body.should == 'another'
   end
 end

data/spec/ramaze/controller/template_resolving.rb

@@ -1,113 +1,77 @@
-#          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'
 
-class MainController < Ramaze::Controller
-  view_root __DIR__(:view)
+class SpecViewAlias < Ramaze::Controller
+  map '/'
 
   def greet(type, message = "Message")
     @greet = "#{type} : #{message}"
   end
 
   def list
-    @obj = Ramaze::Action.current.method
+    @obj = Ramaze::Current.action.method
   end
 
   alias_method :index, :list
-  template :index, 'list'
-  template :non_existant_method, :list
-
+  alias_view :index, :list
+  alias_view :non_existant_method, :list
 end
 
-class OtherController < MainController
+class SpecViewAlias2 < SpecViewAlias
+  map '/other'
 
   def greet__mom(message = "Moms are cool!")
     greet('Mom', message)
   end
-  template :greet__mom, MainController, :greet
+  alias_view :greet__mom, :greet, SpecViewAlias
 
   def greet__other
     @greet = "Other"
   end
-  template :greet__other, :blah
+  alias_view :greet__other, :blah
 
   def greet__another
     @greet = "Another"
   end
-  template :greet__another, :greet__other
+  alias_view :greet__another, :greet__other
 
   def greet__last
     @greet = 'Last'
   end
-  template :greet__last, 'greet/other'
-
-end
-
-class AnotherController < MainController
-  Root = __DIR__/:view
-  Absolute = lambda{|path| File.join Root, path}
-  Relative = lambda{|path| path}
-
-  def greet_absolute(type, message = "Message")
-    @greet = "#{type} : #{message}"
-  end
-  template :greet_absolute, :file => Absolute["greet.xhtml"]
-
-  def greet_relative(type, message = "Message")
-    @greet = "#{type} : #{message}"
-  end
-  template :greet_relative, :file => "greet.xhtml"
-
-  def greet_controller_action(type, message = "Message")
-    @greet = "#{type} : #{message}"
-  end
-  template :greet_controller_action, :controller => MainController, :action => "greet"
-
+  alias_view :greet__last, 'greet__other'
 end
 
-describe "Testing Template overriding" do
-  behaves_like 'http'
-  ramaze :view_root => __DIR__/:view
+describe "Template aliasing" do
+  behaves_like :mock
 
-  it "simple request to greet" do
+  it 'serves normal template' do
     get('/greet/asdf').body.should == '<html>asdf : Message</html>'
   end
 
-  it "referencing template from MainController" do
+  it 'references template from another controller' do
     get('/other/greet/mom').body.should == '<html>Mom : Moms are cool!</html>'
   end
 
-  it "should treat template overrides as possible alternatives (only use if found)" do
+  it 'only uses aliased template if one can be found' do
     get('/other/greet/other').body.should == '<html>Other: Other</html>'
   end
 
-  it "should accept template overrides given as symbols" do
+  it 'accepts aliases given as symbols' do
     get('/other/greet/another').body.should == '<html>Other: Another</html>'
   end
 
-  it "should accept template overrides given as strings" do
+  it 'accepts aliases given as strings' do
     get('/other/greet/last').body.should == '<html>Other: Last</html>'
   end
 
-  it "should set template for aliased :index action" do
+  it 'aliases template for index action' do
     get('/list').body.should == '<html>list</html>'
     get('/index').body.should == '<html>index</html>'
   end
 
-  it "should use template overrides for non-existant actions" do
+  it 'uses aliases even for non-existant actions' do
     get('/non_existant_method').body.should == '<html></html>'
   end
-
-  it "should allow template overrides to be specified by absolute path" do
-    get('/another/greet_absolute/asdf').body.should == '<html>asdf : Message</html>'
-  end
-
-  it "should allow template overrides to be specified by relative path" do
-    get('/another/greet_relative/asdf').body.should == '<html>asdf : Message</html>'
-  end
-
-  it "should allow template overrides to be specified by named controller and action" do
-    get('/another/greet_controller_action/asdf').body.should == '<html>asdf : Message</html>'
-  end
 end

data/spec/ramaze/dispatcher/directory.rb

@@ -2,53 +2,67 @@ require 'spec/helper'
 
 spec_require 'hpricot'
 
-describe 'Dispatcher::Directory' do
+module Ramaze
+  # minimal middleware, no exception handling
+  middleware!(:spec){|m|
+    m.run m.directory(__DIR__('public'))
+  }
+end
+
+describe 'Directory listing' do
+  behaves_like :mock
+
   @hierarchy = %w[
-  /test/deep/hierarchy/one.txt
-  /test/deep/hierarchy/two.txt
-  /test/deep/three.txt
-  /test/deep/four.txt
-  /test/five.txt
-  /test/six.txt ]
+    /test/deep/hierarchy/one.txt
+    /test/deep/hierarchy/two.txt
+    /test/deep/three.txt
+    /test/deep/four.txt
+    /test/five.txt
+    /test/six.txt
+  ]
 
   @hierarchy.each do |path|
     FileUtils.mkdir_p(__DIR__(:public, File.dirname(path)))
     FileUtils.touch(__DIR__(:public, path))
   end
 
+  Ramaze.map('/', lambda{|env| [404, {}, ['not found']]})
+
   def build_listing(path)
-    Ramaze::Dispatcher::Directory.build_listing(path)
+    get('path').body
   end
 
   def check(url, title, list)
-    body, status, header = build_listing(url)
-    status.should == 200
-    header['Content-Type'].should == 'text/html'
+    got = get(url)
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html; charset=utf-8'
 
-    doc = Hpricot(body)
+    doc = Hpricot(got.body)
     doc.at(:title).inner_text.should == title
-    doc.search("//td[@class='n']").map{|td|
-      a = td.at(:a)
-      [ a[:href], a.inner_text ]
-    }.should == list
+
+    (doc/'td.name/a').map{|a| [a[:href], a.inner_text] }.should == list
   end
 
-  it 'should dry serve root directory' do
+  should 'dry serve root directory' do
    files = [
-     ["/../", "Parent Directory"], ["/test", "test/"],
-     ["/favicon.ico", "favicon.ico"], ["/file name.txt", "file name.txt"],
+     ["../", "Parent Directory"],
+     ["/favicon.ico", "favicon.ico"],
+     ["/file name.txt", "file name.txt"],
+     ["/test/", "test/"],
      ["/test_download.css", "test_download.css"]
    ]
 
-    check '/', 'Directory listing of /', files
+    check '/', '/', files
   end
 
-  it 'should serve hierarchies' do
+  should 'serve hierarchies' do
     files = [
-      ["/test/../", "Parent Directory"], ["/test/deep", "deep/"],
-      ["/test/five.txt", "five.txt"], ["/test/six.txt", "six.txt"]
+      ["../", "Parent Directory"],
+      ["/test/deep/", "deep/"],
+      ["/test/five.txt", "five.txt"],
+      ["/test/six.txt", "six.txt"]
     ]
-    check '/test', 'Directory listing of /test', files
+    check '/test', '/test', files
   end
 
   FileUtils.rm_rf(__DIR__('public/test'))