waves-stable 0.7.7 → 2009.3.10

data/lib/dispatchers/default.rb

@@ -2,76 +2,20 @@ module Waves
 
   module Dispatchers
 
-    #
-    # Waves::Dispatchers::Default matches requests against an application's mappings to 
-    # determine what main action to take, as well as what before, after, always, and exception-handling
-    # blocks must run.
-    #
-    # The default dispatcher also attempts to set the content type based on the
-    # file extension used in the request URL. It does this using the class defined in
-    # the current configuration's +mime_types+ attribute, which defaults to Mongrel's
-    # MIME type handler.
-    #
-    # You can write your own dispatcher and use it in your application's configuration
-    # file. By default, they use the default dispatcher, like this:
-    #
-    #   application do
-    #     use Rack::ShowExceptions
-    #     run Waves::Dispatchers::Default.new
-    #   end
-    #
-
     class Default < Base
 
-      # All dispatchers using the Dispatchers::Base to provide thread-safety, logging, etc.
-      # must provide a +safe+ method to handle creating a response from a request.
-      # Takes a Waves::Request and returns a Waves::Reponse
+      # Takes a Waves::Request and returns a Waves::Response    
       def safe( request  )
-
-        response = request.response
-
-        Waves::Application.instance.reload if Waves::Application.instance.debug?
-        response.content_type = Waves::Application.instance.config.mime_types[ request.path ] || 'text/html'
-
-        mapping = Waves::Application.instance.mapping[ request ]
-
-        begin
-
-          mapping[:before].each do | block, args |
-            ResponseProxy.new(request).instance_exec(*args,&block)
-          end
-
-          request.not_found unless mapping[:action]
-
-          block, args = mapping[:action]
-          response.write( ResponseProxy.new(request).instance_exec(*args, &block) )
-          
-          mapping[:after].each do | block, args |
-            ResponseProxy.new(request).instance_exec(*args,&block)
-          end
-
-        rescue Exception => e
-          
-          handler = mapping[:handlers].detect do | exception, block, args |
-            e.is_a? exception
-          end
-          if handler
-            ResponseProxy.new(request).instance_exec(*handler[2], &handler[1])
-          else
-            raise e
-          end
-          
-        ensure
-          mapping[:always].each do | block, args |
-            begin
-              ResponseProxy.new(request).instance_exec(*args,&block) 
-            rescue Exception => e
-              Waves::Logger.info e.to_s
-            end
-          end
-          
+        # set a default content type -- this can be overridden by the resource
+        request.response.content_type = request.accept.default
+        resource = Waves.config.resource.new( request )
+        if request.response.body.empty?
+          request.response.body << resource.process.to_s
+        else
+          resource.process
         end
-
+        # okay, we've handled the request, now write the response unless it was already done
+        request.response.finish
       end
 
     end

data/lib/ext/float.rb

@@ -0,0 +1,13 @@
+module Waves
+  module Ext
+    module Float
+      def to_delimited(delim=',')
+        self.to_s.gsub(/(\d)(?=(\d\d\d)+\.)/, "\\1#{delim}")
+      end
+    end
+  end
+end
+
+class Float # :nodoc:
+  include Waves::Ext::Float
+end

data/lib/{utilities → ext}/hash.rb

@@ -1,5 +1,5 @@
 module Waves
-  module Utilities # :nodoc:
+  module Ext # :nodoc:
     
     # Utility methods mixed into Hash.
     module Hash
@@ -27,5 +27,5 @@ module Waves
 end
 
 class Hash # :nodoc:
-  include Waves::Utilities::Hash
+  include Waves::Ext::Hash
 end

data/lib/{utilities → ext}/integer.rb

@@ -1,5 +1,5 @@
 module Waves
-  module Utilities
+  module Ext
     module Integer
       def seconds ; self ; end
       def minutes ; self * 60 ; end
@@ -15,10 +15,13 @@ module Waves
       def exabytes ; self * 1024.petabytes ; end
       def zettabytes ; self * 1024.exabytes ; end
       def yottabytes ; self * 1024.zettabytes ; end
+      def to_delimited(delim=',')
+        self.to_s.gsub(/(\d)(?=(\d\d\d)+$)/, "\\1#{delim}")
+      end
     end
   end
 end
 
 class Integer # :nodoc:
-  include Waves::Utilities::Integer
+  include Waves::Ext::Integer
 end

data/lib/ext/kernel.rb

@@ -0,0 +1,20 @@
+module Kernel
+  unless respond_to?(:debugger)
+    # Starts a debugging session if ruby-debug has been loaded (call waves-server --debugger to do load it).
+    def debugger
+      Waves::Logger.info "Debugger invoked but not loaded. Start server with --debugger to enable."
+    end
+  end
+
+  unless respond_to?(:engine)
+    # 'engine' exists to provide a quick and easy (and MRI-compatible!) interface to the RUBY_ENGINE constant
+    def engine; defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'; end
+  end
+  
+  def safe_trap(*signals)
+    signals.each { |s| trap(s) { yield } }
+    Thread.new { loop { sleep 1 } } if RUBY_PLATFORM =~ /mswin32/
+  end
+      
+  
+end

data/lib/ext/module.rb

@@ -0,0 +1,20 @@
+module Waves
+  module Ext
+    module Module
+
+      def basename ; self.name.split('::').last || '' ; end
+      def rootname ; self.name.split('::').first ; end
+      def root ; eval( "::#{self.rootname}" ) ; end
+
+      # Just a convenience method for dynamically referencing submodules. Note that
+      # you cannot do const_get, because that will also attempt to deref the cname
+      # at global scope. So it is more efficient to just use eval.
+      def []( cname ) ; eval( "self::#{cname.to_s.camel_case}" ) ; end
+      
+    end
+  end  
+end
+
+class Module # :nodoc:
+  include Waves::Ext::Module
+end

data/lib/{utilities → ext}/object.rb

@@ -1,11 +1,9 @@
 module Waves
-  module Utilities
+  module Ext
     module Object
       # This is an extremely powerful little function that will be built-in to Ruby 1.9.
       # This version is from Mauricio Fernandez via ruby-talk. Works like instance_eval
-      # except that you can pass parameters to the block. This means you can define a block
-      # intended for use with instance_eval, pass it to another method, which can then
-      # invoke with parameters. This is used quite a bit by the Waves::Mapping code.
+      # except that you can pass parameters to the block.
       def instance_exec(*args, &block)
         mname = "__instance_exec_#{Thread.current.object_id.abs}"
         class << self; self end.class_eval{ define_method(mname, &block) }
@@ -21,5 +19,5 @@ module Waves
 end
 
 class Object # :nodoc:
-  include Waves::Utilities::Object
+  include Waves::Ext::Object
 end

data/lib/ext/string.rb

@@ -0,0 +1,20 @@
+# Utility methods mixed into String.
+    
+class String
+  
+  # Syntactic sugar for using File.join to concatenate the argument to the receiver.
+  #
+  #   require "lib" / "utilities" / "string"
+  #
+  # The idea is not original, but we can't remember where we first saw it.
+  # Waves::Ext::Symbol defines the same method, allowing for :files / 'afilename.txt'
+  #
+  
+  def / ( s ) ; File.join( self, s.to_s ); end
+  
+  alias_method :lower_camel_case, :subcamelcase
+  alias_method :camel_case, :camelcase
+  alias_method :snake_case, :snakecase
+  alias_method :title_case, :titlecase
+
+end

data/lib/ext/symbol.rb

@@ -0,0 +1,11 @@
+class Symbol
+
+  # Syntactic sugar for using File.join to concatenate the argument to the receiver.
+  #
+  #   require :lib / :utilities / :string
+  #
+  # The idea is not original, but we can't remember where we first saw it.
+  # Waves::Ext::Symbol defines the same method, allowing for :files / 'afilename.txt'
+
+  def / ( s ) ; File.join( self.to_s, s.to_s ) ; end
+end

data/lib/ext/tempfile.rb

@@ -0,0 +1,5 @@
+require 'tempfile'
+class Tempfile
+  # override method to prevent problem uploading files with Rack
+  def ==(other) ; eql?(other) || super ; end
+end

data/lib/foundations/classic.rb

@@ -0,0 +1,66 @@
+module Waves
+  module Foundations
+    
+    # Provides Sun MVC features for your application.
+    # Includes ERb-style templates. You can also include others via Renderer Layers.
+    # It does NOT include a default ORM. Use an ORM Layer for that.
+    
+    module Classic
+
+      def self.included( app )
+
+        require 'autocode'
+        require 'layers/mvc'
+        require 'layers/inflect/english'
+        require 'helpers/extended'
+        require 'layers/renderers/erubis'
+        require 'layers/renderers/markaby'
+        
+        app.module_eval do
+
+          include AutoCode
+          
+          app.auto_create_module( :Configurations ) do
+            include AutoCode
+            auto_create_class :Default, Waves::Configurations::Default
+            auto_load :Default, :directories => [ :configurations ]
+          end
+
+          app.auto_eval( :Configurations ) do
+            auto_create_class true, app::Configurations::Default
+            auto_load true, :directories => [ :configurations ]
+          end
+
+          app.auto_create_module( :Resources ) do
+            include AutoCode
+            auto_create_class :Default, Waves::Resources::Base
+            auto_load :Default, :directories => [ :resources ]
+          end
+
+          app.auto_eval( :Resources ) do
+            auto_create_class true, app::Resources::Default
+            auto_load true, :directories => [ :resources ]
+            auto_eval :Map do
+              
+              handler( Waves::Dispatchers::NotFoundError ) do
+                app::Views::Errors.new( request ).not_found_404
+              end
+
+            end
+          end
+
+          include Waves::Layers::Inflect::English
+          include Waves::Layers::MVC
+          include Waves::Renderers::Erubis   
+          include Waves::Renderers::Markaby   
+          
+        end
+        
+        Waves << app
+        
+      end
+    end
+  end
+end
+
+

data/lib/foundations/compact.rb

@@ -0,0 +1,50 @@
+module Waves
+  module Foundations
+    module Compact
+      def self.included( app )
+        app.module_eval {
+          const_set( :Resources, Module.new {
+            const_set( :Map, Class.new { 
+              include Waves::Resources::Mixin
+              handler( Exception ) {
+                Waves::Views::Errors.new( request ).server_error_500
+              }
+
+              handler( Waves::Dispatchers::NotFoundError ) {
+                Waves::Views::Errors.new( request ).not_found_404
+              }
+            })
+          })
+          const_set( :Configurations, Module.new {
+            const_set( :Development, Class.new( Waves::Configurations::Default ) {
+              log :level => :debug
+              host '127.0.0.1'
+              port 3000
+              server Waves::Servers::Mongrel
+              resource app::Resources::Map
+            })
+            const_set( :Production, Class.new( self::Development ) {
+              log :level => :error, :output => ( "log.#{$$}" ), :rotation => :weekly
+              port 80
+              host '0.0.0.0'
+              server Waves::Servers::Mongrel
+              application {
+                use Rack::Session::Cookie, :key => 'rack.session',
+                  # :domain => 'foo.com',
+                  :path => '/',
+                  :expire_after => 2592000,
+                  :secret => 'Change it'
+
+                run ::Waves::Dispatchers::Default.new
+              }
+              
+            })
+          })
+        }
+        Waves << app
+      end
+    end
+  end
+end
+
+

data/lib/helpers/basic.rb

@@ -0,0 +1,11 @@
+module Waves
+  module Helpers
+    module Basic
+      attr_reader :request
+      include Waves::ResponseMixin
+      
+      def app ; Waves.main ; end
+      
+    end
+  end
+end

data/lib/helpers/doc_type.rb

@@ -0,0 +1,34 @@
+module Waves
+  
+  module Helpers
+
+    module DocType
+
+      DOCTYPES = {
+        :html3 => "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2//EN\">\n",
+        :html4_transitional =>
+          "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" " <<
+           "\"http://www.w3.org/TR/html4/loose.dtd\">\n",
+        :html4_strict =>
+          "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" " <<
+            "\"http://www.w3.org/TR/html4/strict.dtd\">\n",
+        :html4_frameset =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" " <<
+            "\"http://www.w3.org/TR/html4/frameset.dtd\">\n",
+        :xhtml1_transitional =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" " <<
+            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n",
+        :xhtml1_strict =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" " <<
+            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n",
+        :xhtml1_frameset =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\" " <<
+            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\">\n",
+        :xhtml2 => "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
+      }
+
+      def doctype(type) ; self << DOCTYPES[type||:html4_strict] ; end
+      
+    end
+  end
+end

data/lib/helpers/extended.rb

@@ -0,0 +1,21 @@
+require 'helpers/basic'
+require 'helpers/doc_type'
+require 'helpers/layouts'
+require 'helpers/formatting'
+require 'helpers/model'
+require 'helpers/view'
+require 'helpers/form'
+
+module Waves
+  module Helpers
+    module Extended
+      include Waves::Helpers::Basic
+      include Waves::Helpers::DocType
+      include Waves::Helpers::Layouts
+      include Waves::Helpers::Formatting
+      include Waves::Helpers::Model
+      include Waves::Helpers::View
+      include Waves::Helpers::Form
+    end
+  end
+end

data/lib/helpers/form.rb

@@ -15,7 +15,9 @@ module Waves
     # will invoke the +text+ form view (the template in +templates/form/text.mab+),
     # passing in the name ('blog.title') and the value (@blog.title) as instance variables.
     #
-    # These helpers are Markaby only.
+    # These helpers work best with Markaby, but may work for other Renderers.
+    # 
+    
     module Form
 
       # This method really is a place-holder for common wrappers around groups of