waves-edge 2009.03.10.13.14

data/templates/classic/configurations/default.rb.erb

@@ -0,0 +1,9 @@
+module <%= @name %>
+  module Configurations
+    class Default  < Waves::Configurations::Default      
+    
+	    resource <%= @name %>::Resources::Map
+      
+    end
+  end
+end

data/templates/classic/configurations/development.rb.erb

@@ -0,0 +1,26 @@
+module <%= @name %>
+
+  module Configurations
+
+    class Development < Default
+
+      database :adapter => 'sqlite', :database => '<%= @name.downcase %>'
+
+      reloadable [ <%= @name %> ]
+      log :level => :debug
+      host '127.0.0.1'
+      port 3000
+      dependencies []
+
+      application do
+        use ::Rack::ShowExceptions
+        use ::Rack::Static, :urls => [ '/css/', '/javascript/', '/favicon.ico' ], :root => 'public'
+        run ::Waves::Dispatchers::Default.new
+      end
+
+      server Waves::Servers::Mongrel
+    end
+
+  end
+
+end

data/templates/classic/configurations/production.rb.erb

@@ -0,0 +1,29 @@
+module <%= @name %>
+
+  module Configurations
+
+    class Production < Default
+
+      database :host => 'localhost', :adapter => 'mysql', :database => '<%= @name.downcase %>',
+        :user => 'root', :password => ''
+
+      reloadable []
+
+      log :level => :error,
+        :output => ( :log / "waves.#{$$}" ),
+        :rotation => :weekly
+
+      host '0.0.0.0'
+
+      port 80
+
+      application do
+        use ::Rack::Static, :urls => [ '/css/', '/javascript/', '/favicon.ico' ], :root => 'public'
+        run ::Waves::Dispatchers::Default.new
+      end
+      
+      server Waves::Servers::Mongrel
+
+    end
+  end
+end

data/templates/classic/resources/map.rb.erb

@@ -0,0 +1,8 @@
+module <%= @name %>
+  module Resources
+    class Map
+      include Waves::Resources::Mixin
+      
+    end
+  end
+end

data/templates/classic/startup.rb.erb

@@ -0,0 +1,11 @@
+require 'foundations/classic'
+<% if @orm %>
+require 'layers/orm/providers/<%= @orm %>'
+<% end %>
+
+module <%= @name %>
+  include Waves::Foundations::Classic
+  <% if @orm %>
+  include Waves::Layers::ORM::<%= @orm.camel_case %>
+  <% end %>
+end

data/templates/classic/templates/errors/not_found_404.mab

@@ -0,0 +1,7 @@
+style <<-STYLE
+  body { background: #933; padding: 20px; font-family: verdana, sans-serif; }
+  h1 { font-size: 60px; font-weight: bold; margin: 0px; }
+  p { font-size: 24px; margin: 0px; }
+STYLE
+h1 '404'
+p { 'That URL does not exist on this server.' }

data/templates/classic/templates/errors/server_error_500.mab

@@ -0,0 +1,7 @@
+style <<-STYLE
+  body { background: #c93; padding: 20px; font-family: verdana, sans-serif; }
+  h1 { font-size: 60px; font-weight: bold; margin: 0px; }
+  p { font-size: 24px; margin: 0px; }
+STYLE
+h1 '500'
+p %q( Internal server error. Sorry, but your request could not be processed. )

data/templates/classic/templates/layouts/default.mab

@@ -0,0 +1,14 @@
+doctype :html4_strict
+
+html do
+
+  head do
+    title @title
+  end
+
+  body do
+    layout_content
+  end
+
+end
+

data/templates/compact/startup.rb.erb

@@ -0,0 +1,11 @@
+require 'foundations/compact'
+<% if @orm %>
+require 'layers/orm/<%= @orm %>'
+<% end %>
+
+module <%= @name %>
+  include Waves::Foundations::Compact
+  <% if @orm %>
+  include Waves::Layers::ORM::<%= @orm.camel_case %>
+  <% end %>
+end

data/test/ext/object.rb

@@ -0,0 +1,55 @@
+require "#{File.dirname(__FILE__)}/../helpers.rb"
+
+describe "Object#cache_method_missing" do
+  
+  before do
+    class A; end
+  end
+  
+  after do
+    Object.instance_eval { remove_const(:A) if const_defined?(:A) }
+  end
+  
+  it "defines the missing method" do
+    A.module_eval do
+      def method_missing(name, *args)
+        cache_method_missing name, "'hi'", *args
+      end
+    end
+    A.new.bar
+    A.new.should.respond_to :bar
+  end
+  
+  it "passes along the args" do
+    A.module_eval do
+      def method_missing(name, *args, &block)
+        cache_method_missing name, "args.join('-')", *args
+      end
+    end
+    
+    A.new.bar(1, 2, 3).should == "1-2-3"
+  end
+  
+  it "passes along the block" do
+    A.module_eval do
+      def method_missing(name, *args, &block)
+        cache_method_missing name, "block.call", *args, &block
+      end
+    end
+    
+    A.new.bar { 'bye' }.should == 'bye'
+  end  
+  
+end
+
+describe "Object#instance_exec" do
+  
+  before do
+    @block = lambda { |guy| "Howdy, #{guy}!" }
+  end
+  
+  it "works like instance_eval, but it takes args and gives them to the block" do
+    instance_exec( "Steve", &@block ).should == "Howdy, Steve!"
+  end
+  
+end

data/test/ext/shortcuts.rb

@@ -0,0 +1,73 @@
+require "#{File.dirname(__FILE__)}/../helpers.rb"
+
+describe "Waves::Ext::String" do
+  it "defines / as syntactic sugar for File.join" do
+    ( "lib" / "utilities" ).should == File.join( "lib", "utilities" )
+    ( "lib" / :utilities ).should == File.join( "lib", "utilities" )
+    ( "lib" / 3 ).should == File.join( "lib", "3" )
+  end
+end
+
+describe "A monkeypatch to Symbol" do
+  
+  it "defines / as syntactic sugar for File.join" do
+    ( :lib / :utilities ).should == File.join( "lib", "utilities")
+  end
+  
+end
+
+describe "Waves::Ext::Hash" do
+  
+  it "adds a non-destructive method for converting all hash keys to strings" do
+    h = { :a => 1, 'b' => 2, 3 => 3}
+    h.stringify_keys.should == { 'a' => 1, 'b' => 2, '3' => 3}
+    h.should == { :a => 1, 'b' => 2, 3 => 3}
+  end
+  
+  it "adds a destructive method for converting hash keys to symbols" do
+    h = { "two" => 2, :three => 3}
+    h.symbolize_keys!
+    h.should == { :two => 2, :three => 3 }
+  end
+  
+end
+
+describe "Waves::Ext::Integer" do
+
+  it "has an absolutely pedantic amount of helpers" do
+    1.kilobytes.should == "1_024".to_i
+    1.megabytes.should == "1_048_576".to_i
+    1.gigabytes.should == "1_073_741_824".to_i
+    1.terabytes.should == "1_099_511_627_776".to_i
+    1.petabytes.should == "1_125_899_906_842_624".to_i
+    1.exabytes.should == "1_152_921_504_606_846_976".to_i
+    1.zettabytes.should == "1_180_591_620_717_411_303_424".to_i
+    1.yottabytes.should == "1_208_925_819_614_629_174_706_176".to_i
+  end
+
+end
+
+describe "Waves::Ext::Module" do
+  
+  before do
+    module Eenie; module Meenie; module Miney; end; end ; end
+  end
+  
+  it "defines a basename method" do
+    Eenie::Meenie.basename.should == "Meenie"
+    Eenie::Meenie::Miney.basename.should == "Miney"
+  end
+  
+  it "defines [] for easy access to namespaced constants" do
+    Eenie[:Meenie].should == Eenie::Meenie
+  end
+  
+  it "defines a method for obtaining the outermost constant name" do
+    Eenie::Meenie::Miney.rootname.should == "Eenie"
+  end
+  
+  it "defines a method for obtaining the outermost constant" do
+    Eenie::Meenie::Miney.root.should == Eenie
+  end
+  
+end

data/test/helpers.rb

@@ -0,0 +1,17 @@
+require 'rubygems'; %w{ bacon facon }.each { |dep| require dep }
+
+# Framework lib goes to the front of the loadpath
+$:.unshift('lib')
+require 'waves'
+require 'runtime/mocks'
+
+Waves::Runtime.instance = Waves::Runtime.new
+
+Bacon::Context.module_eval do
+  include Waves::Mocks
+  alias_method :specification, :describe
+  alias_method :feature, :it
+end
+
+Bacon.extend Bacon::TestUnitOutput
+Bacon.summary_on_exit

data/test/match/accept.rb

@@ -0,0 +1,34 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require 'foundations/compact'
+
+describe "Matching The Accepts Header" do
+    
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Waves << Test
+  end
+  
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+    
+  feature "Match an implied accept header using the file extension" do 
+    Test::Resources::Map.on( :get, true, :accept => :javascript ) {}
+    get("/foo.js").status.should == 200
+    get("/foo").status.should == 404
+  end
+  
+  feature "Match against an array of options" do 
+    Test::Resources::Map.on( :get, true, :accept => [ :javascript, :css ] ) {}
+    get("/foo.js").status.should == 200
+    get("/foo").status.should == 404
+  end
+
+  feature "Match against a Mime type (rather than subtype)" do 
+    Test::Resources::Map.on( :get, true, :accept => :image ) {}
+    get("/foo.png").status.should == 200
+    get("/foo").status.should == 404
+  end
+
+end

data/test/match/methods.rb

@@ -0,0 +1,22 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require 'foundations/compact'
+
+describe "Matching Request Methods" do
+    
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Test::Resources::Map.module_eval {
+      %w( get put post delete head ).each { |m| on( m ) { m } } }
+    Waves << Test
+  end
+  
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+    
+  %w( get put post delete head ).each do |m|
+    feature( "Match the '#{m}' method" ) { send( m, '/' ).body.should == m }
+  end
+  
+end

data/test/match/params.rb

@@ -0,0 +1,33 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require 'foundations/compact'
+
+describe "A resource that has matched a request" do
+    
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Waves << Test
+    
+    @request = Waves::Request.new( env('http://localhost/baz?bar=7', :method => 'GET' ) )
+    Test::Resources::Map.on( :get, [ :foo ] ) {}
+    @resource = Test::Resources::Map.new( @request )
+    @resource.get
+  end
+  
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+  
+  it "makes parameters captured from the path available as #captured" do
+    @resource.captured.to_h.should == { 'foo' => 'baz' }
+  end
+  
+  it "makes http query parameters available as #query" do
+    @resource.query.to_h.should == { 'bar' => '7' }
+  end
+  
+  it "provides access to all derived parameters using #params" do
+    @resource.params.to_h.should == { 'foo' => 'baz', 'bar' => '7' }
+  end
+  
+end

data/test/match/path.rb

@@ -0,0 +1,106 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require "foundations/compact"
+
+describe "Matching Request URIs" do
+    
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Waves << Test
+  end
+  
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+
+  feature "By default, we match an arbitrary path." do 
+    Test::Resources::Map.on( :get ) {}
+    get("/foobar").status.should == 200
+    get("/foo/bar").status.should  == 200
+  end
+    
+  feature "A path of true matches an arbitrary path." do 
+    Test::Resources::Map.on( :get, true ) { request.path }
+    get("/foobar").body.should == '/foobar'
+    get("/foo/bar").body.should == '/foo/bar'
+  end
+
+  feature "An empty path matches root." do 
+    Test::Resources::Map.on( :get, [] ) { request.path }
+    get("/").body.should == '/'
+  end
+  
+  feature "A string path component matches that string." do 
+    Test::Resources::Map.on( :get, [ 'foo' ] ) { request.path }
+    get("/foo").body.should == '/foo'
+    get("/bar").status.should == 404
+  end
+
+  feature "A symbol path component captures that component using the symbol as a key." do 
+    Test::Resources::Map.on( :get, [ :foo ] ) { captured[:foo] }
+    get("/foo").body.should == 'foo'
+    get("/bar").body.should == 'bar'
+  end
+
+  feature "A regexp path component matches the any component that matches the regexp." do 
+    Test::Resources::Map.on( :get, [ /\d+/ ] ) { request.path }
+    get("/1234").body.should == '/1234'
+    get("/foo").status.should == 404
+  end
+
+  feature "A path component of true matches the remaining path." do 
+    Test::Resources::Map.on( :get, [ 'foo', true ] ) { request.path }
+    get("/foo/bar/baz").body.should == '/foo/bar/baz'
+    get("/foo").status.should == 404
+  end
+
+  [["one or more", 1..-1, false, true, true],
+   ["zero or more", 0..-1, true, true, true],
+   ["one to N (N=2)", 1..2, false, true, true, false],
+   ["one to N (N=3)", 1..3, false, true, true, true, false]
+  ].each do |name, range, *tests|
+    feature "A Range path component can match #{name} components" do
+      Test::Resources::Map.on(:get, ['foo', range]) { request.path }
+      tests.size.times do |i|
+       get("/foo" * ( i + 1 ) ).status.should == (tests[i] ? 200 : 404)
+      end
+    end
+  end
+  
+  feature "A path component can use a hash with a value of true to capture the remaining path." do 
+    Test::Resources::Map.on( :get, [ 'foo', { :rest => true }  ] ) { captured[:rest] * ' ' }
+    get("/foo/bar/baz").body.should == 'bar baz'
+  end
+
+  [["one or more", 1..-1, false, 'foo', 'foo foo'],
+   ["zero or more", 0..-1, '', 'foo', 'foo foo'],
+   ["one to N (N=2)", 1..2, false, 'foo', 'foo foo', false],
+   ["one to N (N=3)", 0..3, '', 'foo', 'foo foo', 'foo foo foo', false]
+  ].each do |name, range, *tests|
+    feature "A Range path component can match #{name} components" do
+      Test::Resources::Map.on(:get, ['foo', { :rest => range }]) { captured.rest * ' ' }
+      tests.size.times do |i|
+        response = get("/foo" * ( i + 1 ) )
+        tests[i] ? response.body.should == tests[i] : response.status.should == 404
+      end
+    end
+  end
+  
+  feature "A path component can use a hash with a string value to provide a default." do 
+    Test::Resources::Map.on( :get, [ 'foo', { :bar => 'bar' }  ] ) { captured[:bar] }
+    get("/foo/baz").body.should == 'baz'
+    get("/foo").body.should == 'bar'
+  end
+
+  feature "A path component can use a hash with a regexp value to match and capture." do 
+    Test::Resources::Map.on( :get, [ 'foo', { :bar => /\d+/ }  ] ) { captured[:bar] }
+    get("/foo/123").body.should == '123'
+    get("/foo").status.should == 404
+  end
+  
+  it "Path components match against unescaped values" do
+    Test::Resources::Map.on(:get, [ 'polar bear']) { 'bang' }
+    get("/polar%20bear").body.should == 'bang'
+  end
+  
+end