waves 0.7.7 → 0.8.0

data/lib/runtime/mocks.rb

@@ -0,0 +1,14 @@
+module Waves
+  module Mocks
+    
+    def dispatcher ; Waves::Dispatchers::Default ; end
+    def request ; Rack::MockRequest.new( dispatcher.new ) ; end
+    def env( uri, opts ) ; Rack::MockRequest.env_for( uri, opts ) ; end
+    def get( uri, opts = {} ) ; request.get( uri, opts ) ; end
+    def put( uri, opts = {} ) ; request.put( uri, opts ) ; end
+    def post( uri, opts = {} ) ; request.post( uri, opts ) ; end
+    def delete( uri, opts = {} ) ; request.delete( uri, opts ) ; end
+    def head( uri, opts = {} ) ; request.request( 'HEAD', uri, opts ) ; end
+    
+  end
+end

data/lib/runtime/monitor.rb

@@ -0,0 +1,32 @@
+module Waves
+  
+  class Monitor
+    
+    def initialize( options ) ; @options = options ; end
+    
+    def start( manager )
+      @manager = manager
+      @pid = fork do
+        safe_trap('INT','TERM') do
+          Waves::Logger.info "Monitor stopped ..."
+          exit
+        end
+        loop { fix unless check ; sleep interval }
+      end
+    end
+    
+    def fix
+      @manager.restart
+    end
+    
+    # you need to implement this
+    def check ; true ; end
+    
+    # defaults to every 60 seconds
+    def interval ; @options[ :interval ] ; end
+    
+    def stop ; Process.kill( 'INT', @pid ) ; end
+    
+  end
+  
+end

data/lib/runtime/request.rb

@@ -1,78 +1,146 @@
 module Waves
-  # 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.
+  
+  # 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
 
     class ParseError < Exception ; end
 
-    attr_reader :response, :session, :blackboard
+    class Query ; include Attributes ; end
+
+    attr_reader :response, :session, :traits
 
     # 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 )
-      @request = Rack::Request.new( env )
+      @traits = Class.new { include Attributes }.new( :waves => {} )
+      @request = Rack::Request.new( env ).freeze
       @response = Waves::Response.new( self )
       @session = Waves::Session.new( self )
-      @blackboard = Waves::Blackboard.new( self )
     end
     
     def rack_request; @request; end
-
-    # Accessor not explicitly defined by Waves::Request are delegated to Rack::Request.
-    # Check the Rack documentation for more information.
-    def method_missing(name,*args)
-      @request.send(name,*args)
+    
+    # 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
 
     # The request path (PATH_INFO). Ex: +/entry/2008-01-17+
-    def path
-      @request.path_info
-    end
-
-    # The request domain. Ex: +www.fubar.com+
-    def domain
-      @request.host
-    end
-
-    # The request content type.
-    def content_type
-      @request.env['CONTENT_TYPE']
-    end
+    def path ; @request.path_info ; end
 
-    # Supported request methods
-    METHODS = %w{get post put delete head options trace}
+    # Access to "params" - aka the query string - as a hash
+    def query ; @request.params ; end
+    
+    alias_method :params, :query
+    alias_method :domain, :host
 
-    # Override the Rack methods for querying the request method.
-    METHODS.each do |method|
-      class_eval "def #{method}?; method == :#{method} end"
-    end
+    # Request method predicates, defined in terms of #method.
+    %w{get post put delete head options trace}.
+      each { |m| define_method( m ) { method.to_s == m } }
 
     # The request method. Because browsers can't send PUT or DELETE
     # requests this can be simulated by sending a POST with a hidden
     # field named '_method' and a value with 'PUT' or 'DELETE'. Also
     # accepted is when a query parameter named '_method' is provided.
     def method
-      @method ||= begin
-        request_method = @request.request_method.downcase
-        if request_method == 'post'
-          _method = @request['_method']
-          _method.downcase! if _method
-          METHODS.include?(_method) ? _method.intern : :post
-        else
-          request_method.intern
-        end
-      end
+      @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 )
     end
 
     # Raise a not found exception.
     def not_found
-      raise Waves::Dispatchers::NotFoundError.new( @request.url + ' not found.' )
+      raise Waves::Dispatchers::NotFoundError, "#{@request.url} not found." 
     end
 
     # Issue a redirect for the given path.
     def redirect( path, status = '302' )
       raise Waves::Dispatchers::Redirect.new( path, status )
     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
+      
+    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
+
+    module Utilities
+      
+      def self.destructure( hash )
+        destructured = {}
+        hash.keys.map { |key| key.split('.') }.each do |keys|
+          destructure_with_array_keys(hash, '', keys, destructured)
+        end
+        destructured
+      end
 
+      private
+
+      def self.destructure_with_array_keys( hash, prefix, keys, destructured )
+        if keys.length == 1
+          key = "#{prefix}#{keys.first}"
+          val = hash[key]
+          destructured[keys.first.intern] = case val
+          when String
+            val.strip
+          when Hash, Array
+            val
+          when Array
+            val
+          when nil
+            raise key.inspect
+          end
+        else
+          destructured = ( destructured[keys.first.intern] ||= {} )
+          new_prefix = "#{prefix}#{keys.shift}."
+          destructure_with_array_keys( hash, new_prefix, keys, destructured )
+        end
+      end
+      
+    end
+    
   end
 
 end
+
+

data/lib/runtime/response.rb

@@ -1,7 +1,10 @@
 module Waves
+  
   # Waves::Response represents an HTTP response and has methods for constructing a response.
   # These include setters for +content_type+, +content_length+, +location+, and +expires+
-  # headers. You may also set the headers directly using the [] operator. See Rack::Response for documentation of any method not defined here.
+  # headers. You may also set the headers directly using the [] operator. 
+  # See Rack::Response for documentation of any method not defined here.
+  
   class Response
 
     attr_reader :request
@@ -28,7 +31,7 @@ module Waves
     # attempt to further modify the response once this method is called. You don't usually
     # need to call it yourself, since it is called by the dispatcher once request processing
     # is finished.
-    def finish ; request.session.save ; @response.finish ; end
+    def finish ;  @response.finish ; end
 
     # Methods not explicitly defined by Waves::Response are delegated to Rack::Response.
     # Check the Rack documentation for more informations

data/lib/runtime/response_mixin.rb

@@ -3,36 +3,57 @@ module Waves
   # Defines a set of methods that simplify accessing common request and response methods.
   # These include methods not necessarily associated with the Waves::Request and Waves::Response
   # objects, but which may still be useful for constructing a response.
-  #
   # This mixin assumes that a @request@ accessor already exists.
-  module ResponseMixin
+  
+  module ResponseMixin  
+    
     # Access the response.
     def response; request.response; end
-    # Access the request parameters.
-    def params; request.params; end
-    # Access the request session.
-    def session; request.session; end
-    # Access the request path.
-    def path; request.path; end
-    # Access the request url.
-    def url; request.url; end
-    # Access the request domain.
-    def domain; request.domain; end
+    
+    def resource ; traits.waves.resource ; end
+
+    def traits ; request.traits ; end
+    
+    # Access to the query string as a object where the keys are accessors
+    # You can still access the original query as request.query
+    def query ; @query ||= Waves::Request::Query.new( request.query ) ; end    
+    
+    # Elements captured the path
+    def captured ; @captured ||= traits.waves.captured ; end
+    
+    # Both the query and capture merged together
+    def params 
+      query = captured ? request.query.merge( captured.to_h ) : request.query
+      @params ||= Waves::Request::Query.new( query ) 
+    end
+    
+    %w( session path url domain not_found ).each do | m |
+      define_method( m ) { request.send( m ) }
+    end
+    
     # Issue a redirect for the given location.
     def redirect(location, status = '302'); request.redirect(location, status); end
-    # Access the primary application's models
-    def models; Waves.application.models; end
-    # Access the primary application's views
-    def views; Waves.application.views; end
-    # Access the primary application's controllers
-    def controllers; Waves.application.controllers; end
-    # Raise a "not found" exception.
-    def not_found; request.not_found; end
     # Access the Waves::Logger.
     def log; Waves::Logger; end
-    # Access the Blackboard
-    def blackboard; request.blackboard; end
+    # access stuff from an app
+    def app_name ; self.class.rootname.snake_case.to_sym ; end
+    def app ; eval(  "::#{app_name.to_s.camel_case}" ) ; end    
+    def paths( rname = nil )
+      ( rname.nil? ? resource.class.paths : app::Resources[ rname ].paths ).new( request )
+    end
+
+    def basename ; @basename ||= path.sub(/\.([^\.]+)$/,'') ; end
 
+    def extension
+      @extension ||= if ( m = path.match(/\.([^\.]+)$/) ) 
+        m[1]
+      end
+    end
+    
+    def render( path, assigns = {} )
+      Waves::Views::Base.new( request ).render( path, assigns )
+    end
+    
   end
 
 end

data/lib/runtime/runtime.rb

@@ -0,0 +1,67 @@
+module Waves
+
+  # A temporary measure until the applications "array" becomes a hash.
+  # Currently used to keep track of all loaded Waves applications.
+  class Applications < Array
+    def []( name ) ; self.find { |app| app == name.to_s.camel_case } ; end
+  end
+  
+  def self.config; instance.config ; end
+  
+  # The list of all loaded applications
+  def self.applications ; @applications ||= Applications.new ; end
+
+  # Access the principal Waves application.
+  def self.main ; applications.first ; end
+
+  # Register a module as a Waves application.
+  def self.<< ( app )
+    applications << app if Module === app
+  end
+
+  # Returns the most recently created instance of Waves::Runtime.
+  def self.instance ; Waves::Runtime.instance ; end
+  
+  def self.version ; File.read( File.expand_path( "#{File.dirname(__FILE__)}/../../doc/VERSION" ) ) ; end
+  def self.license ; File.read( File.expand_path( "#{File.dirname(__FILE__)}/../../doc/LICENSE" ) ) ; end
+  
+  def self.method_missing(name,*args,&block) ; instance.send(name,*args,&block) ; end
+
+  # A Waves::Runtime takes an inert application module and gives it concrete, pokeable form.
+  # Waves::Server and Waves::Console are types of runtime.
+  class Runtime
+
+    class << self; attr_accessor :instance; end
+
+    # Accessor for options passed to the runtime.
+    attr_reader :options
+
+    # Create a new Waves application instance.
+    def initialize( options={} )
+      @options = options
+      Dir.chdir options[:directory] if options[:directory]
+      Runtime.instance = self
+    end
+
+    # The 'mode' of the runtime determines which configuration it will run under.
+    def mode ; options[:mode]||:development ; end
+    
+    # Returns true if debug was set to true in the current configuration.
+    def debug? ; options[:debugger] or config.debug ; end
+
+    # Returns the current configuration.
+    def config ; Waves.main::Configurations[ mode ] ; end
+
+    # Reload the modules specified in the current configuration.
+    def reload ; config.reloadable.each { |mod| mod.reload } ; end
+
+    # Start and / or access the Waves::Logger instance.
+    def log ; @log ||= Waves::Logger.start ; end
+
+    # Provides access to the server mutex for thread-safe operation.
+    def synchronize( &block ) ; ( @mutex ||= Mutex.new ).synchronize( &block ) ; end
+    def synchronize? ; !options[ :turbo ] ; end
+
+  end
+
+end

data/lib/runtime/server.rb

@@ -1,107 +1,20 @@
 module Waves
-  # You can run the Waves::Server via the +waves-server+ command or via <tt>rake cluster:start</tt>. Run <tt>waves-server --help</tt> for options on the <tt>waves-server</tt> command. The <tt>cluster:start</tt> task uses the +mode+ environment variable to determine the active configuration. You can define +port+ to run on a single port, or +ports+ (taking an array) to run on multiple ports.
-  #
-  # *Example*
-  #
-  # Assume that +ports+ is set in the development configuration like this:
-  #
-  #   ports [ 2020, 2021, 2022 ]
-  #
-  # Then you could start up instances on all three ports using:
-  #
-  #   rake cluster:start mode=development
-  #
-  # This is the equivalent of running:
-  #
-  #   waves-server -c development -p 2020 -d
-  #   waves-server -c development -p 2021 -d
-  #   waves-server -c development -p 2022 -d
-  #
-  # The +cluster:stop+ task stops all of the instances.
-  #
-  class Server < Application
-
-    # Access the server thread.
-    attr_reader :thread
-
-    # Access the host we're binding to (set via the configuration).
-    def host ; options[:host] || config.host ; end
-
-    # Access the port we're listening on (set via the configuration).
-    def port ; options[:port] || config.port ; end
-
-    # Run the server as a daemon. Corresponds to the -d switch on +waves-server+.
-    def daemonize
-      pwd = Dir.pwd
-      Daemonize.daemonize( Waves::Logger.output )
-      Dir.chdir(pwd)
-      File.write( :log / "#{port}.pid", $$ )
-    end
-
-    def trap(signal)
-      Kernel::trap(signal) { yield }
-      Thread.new { loop {sleep 1} } if RUBY_PLATFORM =~ /mswin32/
-    end
-
-    # Start and / or access the Waves::Logger instance.
-    def log
-      @log ||= Waves::Logger.start
-    end
-
-    # Start the server.
-    def start
-      daemonize if options[:daemon]
-      start_debugger if options[:debugger]
-      log.info "** Waves Server starting  on #{host}:#{port}"
-      handler, options = config.handler
-      handler.run( config.application.to_app, options ) do |server|
-        @server = server
-        self.trap('INT') { puts; stop } if @server.respond_to? :stop
-      end
-    end
-
-    # Stop the server.
-    def stop
-      log.info "** Waves Server Stopping ..."
-      if options[:daemon]
-        pid_file = :log / $$ + '.pid'; FileUtils.rm( pid_file ) if File.exist?( pid_file )
-      end
-      @server.stop
-      log.info "** Waves Server Stopped"
+  
+  class Server < Worker
+    
+    def start_tasks
+      @server = config.server.new( application, host, port )
+      @server.start
     end
-
-    # Provides access to the server mutex for thread-safe operation.
-    def synchronize( &block ) ; ( @mutex ||= Mutex.new ).synchronize( &block ) ; end
-
-    class << self
-      private :new, :dup, :clone
-      # Start or restart the server.
-      def run( options={} )
-        @server.stop if @server; @server = new( options ); @server.start
-      end
-      
-      # Allows us to access the Waves::Server instance.
-      def method_missing(*args)
-        @server.send(*args)
-      end
-      
-      #-- Probably wouldn't need this if I added a block parameter to method_missing.
-      def synchronize(&block) ; @server.synchronize(&block) ; end
-    end
-
+    
+    def stop_tasks ; @server.stop ; end
+    
     private
 
-    def start_debugger
-      begin
-        require 'ruby-debug'
-        Debugger.start
-        Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
-        log.info "Debugger enabled"
-      rescue Exception
-        log.info "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
-        exit
-      end
-    end
+    def application ; @app ||= config.application.to_app ; end
+    def port ; @port ||= options[:port] or config.port ; end
+    def host ; @host ||= options[:host] or config.host ; end
+
   end
 
-end
+end