waves 0.8.2 → 0.9.0

data/lib/waves/renderers/mixin.rb

@@ -0,0 +1,9 @@
+module Waves
+  module Renderers
+    module Mixin
+
+      # Placeholder
+
+    end
+  end
+end

data/lib/waves/request/accept.rb

@@ -0,0 +1,92 @@
+module Waves
+  class Accept < Array
+
+    #
+    # RFC 2616 section 14.1.
+    #
+    # Returns an array of elements of the form:
+    #
+    # [ term, params ]
+    #
+    # where is term is an array of MIME type components,
+    # with the true value as the wildcard (*)
+    #
+    # and where params is a hash of parameters (q, level, etc.),
+    # where the q param is auto-converted to a float and 
+    # defaulted to 1.0.
+    #
+    # sorted by q value and then specificity, with ties going
+    # to HTML-related media-types
+    #
+    #
+    # TODO  parsing must be optimized. This parses Accept,
+    #       lang and charset
+    #
+    def Accept.parse(str)
+      return self.new if str.nil?
+      self.new( Accept.sort( str.split(',').map { |term| Accept.parse_media_type( term ) } ).uniq )
+    end
+  
+    def Accept.parse_media_type( term )
+      t, *p = term.to_s.split(';').map(&:strip) 
+      [ Accept.parse_media_range( t ), Accept.convert_params_to_hash( p ) ]
+    end
+  
+    def Accept.parse_media_range( t )
+      t.split('/').map(&:strip).map { |x| x=='*' ? true : x }
+    end
+  
+    def Accept.convert_params_to_hash( p )
+      rval = p.inject({}) { |h,p|
+        k,v = p.split('=').map(&:strip)
+        ( v = v.to_f ) if k == 'q'
+        h[k] = v ; h
+      }
+      rval['q'] ||= 1.0
+      rval
+    end
+  
+    def Accept.sort( terms )
+      terms.sort { |t1,t2| 
+        # first compare on quality
+        c = t2[1]['q'] <=> t1[1]['q']
+        # next compare on specificity of the media type
+        c = t2[0].size <=> t1[0].size if ( c == 0 )
+        # finally, compare on specificity of parameters
+        c = t2[1].size <=> t1[1].size if ( c == 0 )
+        c
+      }
+    end
+  
+    def Accept.to_media_type( term )
+      term.first.map { |x| x==true ? '*' : x }.join("/")
+    end
+
+    def =~(arg) ; self.include? arg ; end
+    def ===(arg) ; self.include? arg ; end
+
+    # Check these Accepts against constraints.
+    #
+    def include?(arg)
+      # recursively test for any possibility if we get an array
+      # thus you can match against, say, %w( png jpg gif )
+      return arg.any? {|pat| self.include? pat } if arg.kind_of? Array
+      term = Accept.parse_media_type( arg ).first
+      self.map(&:first).any? { | type, subtype |
+        case term
+        when [ type ], [ subtype ], [ true ],
+            [ type, subtype ], [ type, true ], 
+            [ true, true ] then true
+        else false
+        end
+      }
+    end
+
+    # Again, we play favorites here: in the absence of any accept header
+    # we go with 'text/html' as our favorite
+    def preferred_media_type
+      Accept.to_media_type( first ) || 'text/html'
+    end
+
+  end
+end

data/lib/{runtime → waves/request}/request.rb

@@ -1,6 +1,6 @@
 module Waves
-  
-  # Waves::Request represents an HTTP request and provides convenient methods for accessing request attributes. 
+
+  # Waves::Request represents an HTTP request and provides convenient methods for accessing request attributes.
   # See Rack::Request for documentation of any method not defined here.
 
   class Request
@@ -13,26 +13,44 @@ module Waves
 
     # Create a new request. Takes a env parameter representing the request passed in from Rack.
     # You shouldn't need to call this directly.
-    def initialize( env )
+    #
+    def initialize(env)
       @traits = Class.new { include Attributes }.new( :waves => {} )
-      @request = Rack::Request.new( env ).freeze
+      @request = Rack::Request.new(env).freeze
       @response = Waves::Response.new( self )
-      @session = Waves::Session.new( self )
     end
-    
-    def rack_request; @request; end
-    
+
+    # Rack request object.
+    #
+    def rack_request()
+      @request
+    end
+
     # Methods delegated directly to rack
     %w( url scheme host port body query_string content_type media_type content_length referer ).each do |m|
       define_method( m ) { @request.send( m ) }
     end
 
+    # access common HTTP headers as methods
+    %w( user_agent cache_control ).each do |name|
+      key = "HTTP_#{name.to_s.upcase}"
+      define_method( name ) { @request.env[ key ] if @request.env.has_key?( key ) } 
+    end
+    
+    def if_modified_since
+      @if_modified_since ||= 
+        ( Time.parse( @request.env[ 'HTTP_IF_MODIFIED_SINCE' ] ) if 
+          @request.env.has_key?( 'HTTP_IF_MODIFIED_SINCE' ) ) 
+    end
+
+    def []( key ) ; @request.env[ key.to_s ] ; end
+
     # The request path (PATH_INFO). Ex: +/entry/2008-01-17+
     def path ; @request.path_info ; end
 
     # Access to "params" - aka the query string - as a hash
     def query ; @request.params ; end
-    
+
     alias_method :params, :query
     alias_method :domain, :host
 
@@ -45,67 +63,65 @@ module Waves
     # field named '_method' and a value with 'PUT' or 'DELETE'. Also
     # accepted is when a query parameter named '_method' is provided.
     def method
-      @method ||= ( ( ( m = @request.request_method.downcase ) == 'post' and 
+      @method ||= ( ( ( m = @request.request_method.downcase ) == 'post' and
         ( n = @request['_method'] ) ) ? n.downcase : m ).intern
     end
-    
-    def []( key ) ; @request.env[ key.to_s.upcase ] ; end
-    
-    # access HTTP headers as methods
-    def method_missing( name, *args, &body )
-      return super unless args.empty? and body.nil?
-      key = "HTTP_#{name.to_s.upcase}" 
-      @request.env[ key ] if @request.env.has_key?( key )
+
+    # Requested representation MIME type
+    def accept()
+      @accept ||= Accept.parse(@request.env['HTTP_ACCEPT'])
     end
 
-    # Raise a not found exception.
-    def not_found
-      raise Waves::Dispatchers::NotFoundError, "#{@request.url} not found." 
+    # Combination of Accept and file extension for matching.
+    #
+    # A file extension takes precedence over the Accept
+    # header, the Accept is ignored.
+    #
+    # The absence of a file extension is indicated using
+    # the special MIME type MimeTypes::Unspecified, which
+    # allows specialised handling thereof. The resource
+    # must specifically accept Unspecified for it to have
+    # an effect.
+    #
+    # @see  matchers/requested.rb
+    # @see  #accept
+    # @see  #ext
+    # @see  runtime/mime_types.rb for the actual definition
+    #       of the Unspecified type.
+    #
+    def requested()
+      @requested ||= ( extension ? Accept.new( Accept.parse( MimeTypes[ extension ].join(",") ) + accept ).uniq : accept )
     end
 
-    # Issue a redirect for the given path.
-    def redirect( path, status = '302' )
-      raise Waves::Dispatchers::Redirect.new( path, status )
+    # Requested charset(s).
+    #
+    # @see  matchers/accept.rb
+    #
+    def accept_charset()
+      @charset ||= Accept.parse(@request.env['HTTP_ACCEPT_CHARSET'])
     end
-        
-    class Accept < Array
-      
-      def =~(arg) ; self.include? arg ; end
-      def ===(arg) ; self.include? arg ; end
-      
-      def include?(arg)
-        return arg.any? { |pat| self.include?( pat ) } if arg.is_a? Array
-        arg = arg.to_s.split('/')
-        self.any? do |entry|
-          false if entry == '*/*' or entry == '*'
-          entry = entry.split('/')
-          if arg.size == 1 # implicit wildcard in arg
-            arg[0] == entry[0] or arg[0] == entry[1]
-          else
-            arg == entry
-          end
-        end
-      end
-      
-      def self.parse(string)
-        string.split(',').inject(self.new) { |a, entry| a << entry.split( ';' ).first.strip; a }
-      end
-      
-      def default
-        return 'text/html' if self.include?('text/html')
-        find { |entry| ! entry.match(/\*/) } || 'text/html'
-      end
-      
+
+    # Requested language(s).
+    #
+    # @see  matchers/accept.rb
+    #
+    def accept_language()
+      @lang ||= Accept.parse(@request.env['HTTP_ACCEPT_LANGUAGE'])
+    end
+
+    # File extension of path, with leading dot
+    def extension
+      @ext ||= ( ( e = File.extname( path ) ).empty? ? nil : e )
     end
     
-    # this is a hack - need to incorporate browser variations for "accept" here ...
-    # def accept ; Accept.parse(@request.env['HTTP_ACCEPT']).unshift( Waves.config.mime_types[ path ] ).compact.uniq ; end
-    def accept ; @accept ||= Accept.parse( Waves.config.mime_types[ path.downcase ] || 'text/html' ) ; end
-    def accept_charset ; @charset ||= Accept.parse(@request.env['HTTP_ACCEPT_CHARSET']) ; end
-    def accept_language ; @lang ||= Accept.parse(@request.env['HTTP_ACCEPT_LANGUAGE']) ; end
+    alias :ext :extension
+
+    def basename
+      @basename ||= File.basename( path )
+    end
 
     module Utilities
-      
+
       def self.destructure( hash )
         destructured = {}
         hash.keys.map { |key| key.split('.') }.each do |keys|
@@ -136,9 +152,9 @@ module Waves
           destructure_with_array_keys( hash, new_prefix, keys, destructured )
         end
       end
-      
+
     end
-    
+
   end
 
 end

data/lib/waves/resources/file_mixin.rb

@@ -0,0 +1,11 @@
+module Waves::Resources::FileMixin
+  
+  def load_from_file( path )
+    if File.exist?( path )
+      http_cache( File.mtime( path ) ) {
+        File.read( path )
+      }
+    end
+  end
+  
+end

data/lib/{resources → waves/resources}/mixin.rb

@@ -1,18 +1,13 @@
 module Waves
-  
+
   module Resources
-    
-    StatusCodes = {
-      Waves::Dispatchers::NotFoundError => 404
-    }
-    
-    
+
     module Mixin
-      
+
       attr_reader :request
-      
+
       module ClassMethods
-          
+
         def paths
           unless @paths
             resource = self
@@ -46,7 +41,7 @@ module Waves
           methods.each do | method |
             functor_with_self( method, matcher, &block )
           end
-          paths.module_eval { 
+          paths.module_eval {
             define_method( generator ) { | *args | generate( path, args ) }
           } if generator
         end
@@ -62,71 +57,74 @@ module Waves
         end
         def handler( exception, &block ) ; functor( :handler, exception, &block ) ; end
         def always( &block ) ; define_method( :always, &block ) ; end
-        
+
       end
 
       # this is necessary because you can't define functors within a module because the functor attempts
       # to incorporate the superclass functor table into it's own
       def self.included( resource )
-        
-        resource.module_eval do 
-      
+
+        resource.module_eval do
+
           include ResponseMixin, Functor::Method ; extend ClassMethods
 
           def initialize( request ); @request = request ; end
-      
+
+          # define defaults for all the functors, providing the analog
+          # of "not implemented" behaviors. this avoids complicating
+          # the error handling with having to distinguish between
+          # functor match-related errors and actual application errors
+          
+          # by default, don't do anything in the wrapper methods
+          before {} ; after {} ; always {}
+
+          # if we get here, this is a 404
+          %w( post get put delete head ).each do | method |
+            on( method ) { not_found }
+          end
+          
+          # default handler is just to propagate the exception
+          handler( Exception ) { |e| raise( e ) }
+
           def process
             begin
-              before ; body = send( request.method ) ; after
-            rescue Waves::Dispatchers::Redirect => e
-              raise e
+              before ;  rval = send( request.method ) ; after
             rescue Exception => e
-              response.status = ( StatusCodes[ e.class ] || 500 )
-              ( body = handler( e ) ) rescue raise e
-              Waves::Logger.warn e.to_s
-              e.backtrace.each { |t| Waves::Logger.debug "    #{t}" }
+              e.call( response ) if e.respond_to?( :call )
+              rval = handler( e )
             ensure
               always
             end
-            return body
+            # note: the dispatcher decides what to do with the
+            # return value; all we care about is returning the
+            # value from the appropriate application block
+            return rval
           end
-      
+
           def to( resource )
             resource = case resource
             when Base
               resource
             when Symbol, String
-              begin 
-                Waves.main::Resources[ resource ]
-              rescue NameError
-                raise Waves::Dispatchers::NotFoundError
-              end
               Waves.main::Resources[ resource ]
             end
             r = traits.waves.resource = resource.new( request )
             r.process
           end
-          
+
           def redirect( path ) ; request.redirect( path ) ; end
-      
-          # override for resources that may have long-running requests. this helps servers 
+
+          # override for resources that may have long-running requests. this helps servers
           # determine how to handle the request
           def deferred? ; false ; end
-          
-          before {} ; after {} ; always {}
-          # handler( Waves::Dispatchers::Redirect ) { |e| raise e }
-      
-          %w( post get put delete head ).each do | method |
-            on( method ) { not_found }
-          end
-                
+
         end
-        
+
       end
 
     end
-      
-    class Base ; include Mixin ; end 
+
+    class Base ; include Mixin ; end
 
   end
 

data/lib/waves/resources/paths.rb

@@ -0,0 +1,132 @@
+module Waves
+  
+  module Resources
+    
+    class Paths
+      
+      def self.compiled; @compiled ||= {} ; end
+      
+      def compiled_paths; self.class.compiled ; end
+      
+      def generate( template, args )
+        return "/" if template.empty?
+        if template.is_a? Array
+          if args.size == 1 and args.first.is_a? Hash
+            process_hash( template, args.first )
+          else
+            process_array( template, args)
+          end
+        else
+          "/#{ args * '/' }"
+        end
+      end
+      
+      def process_array( template, args )
+        template_key = template
+        compiled = compiled_paths[template_key]
+        if compiled
+          return ( compiled % args ) rescue raise [template, args].inspect
+        end
+        compilable = true
+        cpath, interpolations = "", []
+        result = ( cpath % interpolations ) if template.all? do | want |
+          case want
+          when Symbol
+            cpath << "/%s" ; interpolations << args.shift
+          when String
+            cpath << "/#{want}"
+          when true
+            compilable = false
+            cpath += "/#{args.join("/")}"; args = []
+          when Hash
+            compilable = false
+            key, value = want.to_a.first
+            case value
+            when true
+              cpath += "/#{args.join("/")}"; args = []
+            when String, Symbol
+              compilable = true
+              component = args.shift
+              cpath << "/%s"
+              component ? interpolations << component : interpolations << value 
+            when Regexp
+              component = args.shift.to_s
+              raise ArgumentError, "#{component} does not match #{want.inspect}" unless component =~ value
+              cpath << "/%s"; interpolations << component
+            end
+          when Regexp
+            compilable = false
+            component = args.shift.to_s
+            raise ArgumentError, "#{component} does not match #{want.inspect}" unless component =~ want
+            cpath << "/%s"; interpolations << component
+          end
+        end
+        raise ArgumentError, "Too many args" unless args.empty?
+        compiled_paths[template_key] = cpath if compilable
+        result
+      end
+      
+      def process_hash( template, hash )
+        path = []
+        ( "/#{ path * '/' }" ) if template.all? do |want|
+          case want
+          when Symbol
+            raise ArgumentError, "Path generator needs a value for #{want.inspect}" unless component = hash[want]
+            path << component
+          when String then path << want
+          when Hash
+            key, value = want.to_a.first
+            case value
+            when Regexp
+              raise ArgumentError, "Path generator needs a value for #{want.inspect}" unless component = hash[key]
+              raise ArgumentError, "#{component} does not match #{want.inspect}" unless component =~ value
+              path << component
+            when String, Symbol
+              hash.has_key?(key) ? path << hash[key] : path << value
+            when true
+              raise ArgumentError, "Path generator needs a value for #{want.inspect}" unless component = hash[key]
+              path += [component].flatten
+            end
+          when Regexp, true
+            raise ArgumentError, "Path generator can't take an args hash, as it contains a Regexp or the value true"           
+          end
+        end
+      end
+      
+      def original_generate( template, args )
+        if template.is_a? Array and not template.empty?
+          path = []
+          ( "/#{ path * '/' }" ) if template.all? do | want |
+            case want
+            when true then path += args
+            when String then path << want
+            when Symbol then path << args.shift
+            when Regexp
+              component = args.shift.to_s
+              raise ArgumentError, "#{component} does not match #{want.inspect}" unless component =~ want
+              path << component
+            when Hash
+              key, value = want.to_a.first
+              case value
+              when true then path += args
+              when String, Symbol
+                # if no args to interpolate, use hash element value as default
+                !args.empty? ? path << args.shift : path << value
+              when Regexp
+                component = args.shift.to_s
+                raise ArgumentError, "#{component} does not match #{want.inspect}" unless component =~ value
+                path << component
+              end
+            end
+          end
+        else
+          "/#{ args * '/' }"
+        end
+      end
+      
+      
+      
+    end
+  end
+
+end