waves-edge 2009.03.10.13.14

data/lib/matchers/base.rb

@@ -0,0 +1,30 @@
+module Waves
+
+  module Matchers
+
+    class Base
+      
+      attr_accessor :constraints
+      
+      def []( *args ) ; call( *args ) ; end
+      
+      # used to provide consisting matching logic across all matchers
+      def test( request )
+        constraints.all? do | key, val |
+          if val.nil? or val == true
+            true
+          else
+            if val.respond_to? :call
+              val.call( request )
+            else
+              val == request.send( key ) or val === request.send( key ) or request.send( key ) === val
+            end
+          end
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/matchers/content_type.rb

@@ -0,0 +1,17 @@
+module Waves
+
+  module Matchers
+
+    class ContentType < Base
+      
+      def initialize( content_type ) ; @constraints = { :content_type => content_type } ; end
+    
+      # we could maybe do something more sophisticated here, matching against content type patterns
+      # such */html or */xml, etc.; adapt from the matching done on accepts ... ?
+      def call( request ) ; test( request ) ; end
+      
+    end
+    
+  end
+  
+end

data/lib/matchers/path.rb

@@ -0,0 +1,67 @@
+module Waves
+
+  module Matchers
+    
+    class Path < Base
+      
+      # Takes an array of pattern elements ... coming soon, support for formatted strings!
+      def initialize( pattern ) ; @pattern = pattern  ; end
+      
+      # returns a hash of captured values
+      def call( request )
+        if @pattern.is_a? Array
+          path = extract_path( request ).reverse
+          return {} if @pattern.empty? && path.empty?
+          capture = {}
+          match = @pattern.all? do | want |
+            case want
+            when true # same as a Range of 1..-1
+              path = [] unless path.empty?
+            when Range 
+              if want.end == -1
+                path = [] if path.length >= want.begin
+              else
+                path = [] if want.include? path.length
+              end
+            when String then want == path.pop
+            when Symbol then capture[ want ] = path.pop
+            when Regexp then want === path.pop
+            when Hash
+              key, value = want.to_a.first
+              case value
+              when true
+                ( capture[ key ], path = path.reverse, [] ) unless path.empty?
+              when Range
+                if value.end == -1
+                  ( capture[ key ], path = path.reverse, [] ) if path.length >= value.begin
+                else
+                  ( capture[ key ], path = path.reverse, [] ) if value.include? path.length
+                end
+              when String, Symbol
+                got = path.pop
+                capture[ key ] = got ? got : value.to_s
+              when Regexp then
+                got = path.pop
+                capture[ key ] = got if value === got
+              end
+            end
+          end
+          capture if match && path.empty?
+        elsif @pattern == true or @pattern == false or @pattern == nil
+          {}
+        end
+      end
+
+      # private 
+
+      # just a little helper method
+      def extract_path( request )
+        request.traits.waves.path ||= request.path.scan(/[^\/]+/).map { |e| Rack::Utils.unescape(e) }
+      end
+
+    end
+    
+    
+  end
+
+end

data/lib/matchers/query.rb

@@ -0,0 +1,21 @@
+module Waves
+
+  module Matchers
+
+    class Query < Base
+      
+      def initialize( pattern ) ; @pattern = ( pattern or {} ) ; end
+    
+      def call( request )
+        @pattern.all? do | key, val |
+          key = key.to_s
+          ( ( val.respond_to?(:call) and val.call( request.query[ key ] ) ) or 
+            ( request.query[ key ] and ( ( val == true ) or ( val === request.query[ key ] ) ) ) )
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/matchers/request.rb

@@ -0,0 +1,27 @@
+module Waves
+
+  module Matchers
+
+    class Request < Base
+      
+      def initialize( options )
+        @uri = Matchers::URI.new( options )
+        @constraints = {
+          :content_type => Matchers::ContentType.new( options[ :content_type ] ),
+          :accept => Matchers::Accept.new( options ),
+          :query => Matchers::Query.new( options[:query] ),
+          :traits => Matchers::Traits.new( options[:traits] )
+        }
+      end
+
+      def call( request )
+        if test( request ) and captured = @uri[ request ]
+          request.traits.waves.captured = captured
+        end
+      end
+          
+    end
+    
+  end
+  
+end

data/lib/matchers/resource.rb

@@ -0,0 +1,19 @@
+module Waves
+
+  module Matchers
+
+    class Resource
+      
+      def initialize( options )
+        @matcher = Waves::Matchers::Request.new( options )
+      end
+
+      def call( resource ) ; @matcher.call( resource.request ) ; end
+      def []( *args ) ; call( *args ) ; end
+      
+          
+    end
+    
+  end
+  
+end

data/lib/matchers/traits.rb

@@ -0,0 +1,19 @@
+module Waves
+
+  module Matchers
+
+    class Traits < Base
+      
+      def initialize( pattern ) ; @pattern = ( pattern or {} ) ; end
+    
+      def call( request )
+        @pattern.all? do | key, val |
+          ( val.is_a? Proc and val.call( request.traits[ key ] ) ) or val === request.traits[ key ]
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/matchers/uri.rb

@@ -0,0 +1,20 @@
+module Waves
+
+  module Matchers
+
+    class URI < Base
+      
+      def initialize( options )
+        @path = Waves::Matchers::Path.new( options[ :path ] )
+        @constraints = { :server => options[ :server ], :scheme => options[ :scheme ] }
+      end
+    
+      def call( request )
+        @path.call( request ) if test( request )
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/renderers/mixin.rb

@@ -0,0 +1,13 @@
+module Waves
+
+  module Renderers # :nodoc:
+
+    module Mixin
+
+      
+
+    end
+
+  end
+
+end

data/lib/resources/mixin.rb

@@ -0,0 +1,136 @@
+module Waves
+  
+  module Resources
+    
+    StatusCodes = {
+      Waves::Dispatchers::NotFoundError => 404
+    }
+    
+    
+    module Mixin
+      
+      attr_reader :request
+      
+      module ClassMethods
+          
+        def paths
+          unless @paths
+            resource = self
+            @paths = Class.new( superclass.respond_to?( :paths ) ? superclass.paths : Waves::Resources::Paths ) do
+              @resource = resource
+              def self.resource ; @resource ; end
+            end
+          else
+            @paths
+          end
+        end
+        def with( options ) ; @options = options ; yield ; @options = nil ; end
+        def on( method, path = true, options = nil, &block )
+          if path.is_a? Hash
+            generator = path.keys.first
+            path = path.values.first
+          end
+          if options
+            options[ :path ] = path
+          else
+            options = { :path => path }
+          end
+          options = @options.merge( options ) if @options
+          matcher = Waves::Matchers::Resource.new( options )
+          methods = case method
+            when nil then nil
+            when true then [ :post, :get, :put, :delete ]
+            when Array then method
+            else [ method ]
+          end
+          methods.each do | method |
+            functor_with_self( method, matcher, &block )
+          end
+          paths.module_eval { 
+            define_method( generator ) { | *args | generate( path, args ) }
+          } if generator
+        end
+        def before( path = nil, options = {}, &block )
+          on( :before, path, options, &block )
+        end
+        def after( path = nil, options = {}, &block )
+          on( :after, path, options, &block )
+        end
+        def wrap( path = nil, options = {}, &block )
+          before( path, options, &block )
+          after( path, options, &block )
+        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 
+      
+          include ResponseMixin, Functor::Method ; extend ClassMethods
+
+          def initialize( request ); @request = request ; end
+      
+          def process
+            begin
+              before ; body = send( request.method ) ; after
+            rescue Waves::Dispatchers::Redirect => e
+              raise e
+            rescue Exception => e
+              response.status = ( StatusCodes[ e.class ] || 500 )
+              ( body = handler( e ) ) rescue raise e
+              Waves::Logger.warn "Handled #{e.class}: #{e}"
+              e.backtrace.each { |t| Waves::Logger.debug "    #{t}" }
+            ensure
+              always
+            end
+            return body
+          end
+      
+          def to( resource )
+            resource = case resource
+            when Base
+              resource
+            when Symbol, String
+              begin 
+                Waves.main::Resources[ resource ]
+              rescue NameError => e
+                Waves::Logger.debug e.to_s
+                e.backtrace.each { |t| Waves::Logger.debug "    #{t}" }
+                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 
+          # 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 
+
+  end
+
+
+end

data/lib/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