waves 0.7.7 → 0.8.0

data/lib/runtime/session.rb

@@ -3,62 +3,23 @@ module Waves
   # Encapsulates the session associated with a given request. A session has an expiration
   # and path, which must be provided in a Waves::Configuration. Sensible defaults are defined
   # in Waves::Configurations::Default
+  
   class Session
-    
-    # Concoct a (probably) unique session id
-    def self.generate_session_id 
-      # from Camping ...
-      chars = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
-      (0..48).inject(''){|s,x| s+=chars[ rand(chars.length) ] }
-    end
 
     # Create a new session object using the given request. This is not necessarily the
-    # same as constructing a new session. The session_id cookie for the request domain
-    # is used to store a session id. The actual session data will be stored in a directory
-    # specified by the application's configuration file.
+    # same as constructing a new session. See Rack::Sesssion for more info.
     def initialize( request )
-      @request = request
-      @data ||= ( File.exist?( session_path  ) ? load_session : {} )
+      @data = request.rack_request.env['rack.session']
     end
     
     # Return the session data as a hash
-    def to_hash
-      @data.to_hash
-    end
+    def to_hash ; @data ; end
     
-    def self.base_path
-      Waves::Application.instance.config.session[:path]
-    end
-
-    # Save the session data. You shouldn't typically have to call this directly, since it
-    # is called by Waves::Response#finish.
-    def save
-      if @data && @data.length > 0
-        File.write( session_path, @data.to_yaml )
-        @request.response.set_cookie( 'session_id',
-          :value => session_id, :path => '/',
-          :expires => Time.now + Waves::Server.config.session[:duration] )
-      end
-    end
-
     # Access a given data element of the session using the given key.
     def [](key) ; @data[key] ; end
     # Set the given data element of the session using the given key and value.
     def []=(key,val) ; @data[key] = val ; end
 
-    private
-
-    def session_id
-      @session_id ||= ( @request.cookies['session_id'] || Waves::Session.generate_session_id )
-    end
-
-    def session_path
-      Waves::Session.base_path / session_id
-    end
-
-    def load_session
-      YAML.load( File.read( session_path ) )
-    end
 
   end
 

data/lib/runtime/worker.rb

@@ -0,0 +1,86 @@
+require 'drb'
+module Waves
+  
+  # "Workers" are just dedicated processes. Managers, Servers, and Monitors are all
+  # examples of Workers. This class just encapsulates the common features across all
+  # Workers: daemonization, signal traps, console support, logging, only-ness, etc.
+  
+  class Worker < Runtime
+    
+    def self.run( options )
+      @instance ||= new( options )
+      Kernel.load( options[:startup] || 'startup.rb' )
+      @instance.start
+    end
+    
+    # make this the one-and-only
+    def self.instance ; @instance ; end
+    class << self ; private :new, :allocate ; end
+    private :dup, :clone
+    
+    # returns the PID of the new process
+    def start
+      pid = daemonize if options[ :daemon ]
+      return pid if pid
+      # from here on in, we're in the daemon
+      start_logger ; Waves::Logger.info "#{self.class} starting ..."
+      start_debugger if debug? unless Kernel.engine == 'jruby'
+      # various ways to talk to a worker
+      set_traps ; start_console ; start_drb
+      start_tasks.join
+    end
+    
+    def stop
+      Waves::Logger.info "#{self.class} shutting down ..."
+      @console.stop if @console
+      stop_tasks
+    end
+    
+    def restart ; stop ; start ; end
+        
+    def daemonize
+      pwd = Dir.pwd ; pid = fork ; return pid if pid ; Dir.chdir( pwd )
+      File.umask 0000 ; STDIN.reopen( '/dev/null') ; 
+      STDOUT.reopen( '/dev/null', 'a' ) ; STDERR.reopen( STDOUT )
+      nil # return nil for child process, just like fork does
+    end
+    
+    def set_traps
+      safe_trap( 'HUP' ) { restart }
+      safe_trap( 'TERM','INT' ) { stop }
+    end
+    
+    def start_logger
+      Waves::Logger.start
+      Waves::Logger.info "Logger started."
+    end
+    
+    def start_console
+      if config.console
+        @console = config.console ; @console.start
+        Waves::Logger.info "Console started on port #{config.console.port}"
+      end
+    end
+    
+    def start_debugger
+      require 'ruby-debug' ; Debugger.start
+      Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+      Waves::Logger.info "ruby-debug enabled"
+    end
+    
+    protected 
+    
+    # workers should override these methods
+    def start_tasks
+    end
+
+    def stop_tasks
+    end
+    
+    # for management, monitoring
+    def start_drb
+    end
+    
+  end
+  
+end

data/lib/servers/base.rb

@@ -0,0 +1,42 @@
+module Waves
+  
+  module Servers
+    
+    # Inherit from this class and define the #call method to create Servers.
+    # Like Rack Handlers, except with an attempt at a more generic interface.
+    # The #call method should yield with the actual server object.
+    
+    class Base
+      
+      attr_reader :application, :host, :port
+      def initialize( application, host, port )
+        @application = application
+        @host = host ;@port = port
+      end
+      
+      # starts server, retrying every second until it succeeds
+      def start
+        Thread.new do
+          connect = false
+          until connect do
+            begin
+              call do |server| 
+                @server = server
+                Waves::Logger.info "#{self.class.basename} started on #{host}:#{port}."
+              end
+            rescue RuntimeError => e
+              Waves::Logger.error e.to_s
+              sleep 1
+            end
+            connect = true
+          end
+        end
+      end
+      
+      def stop
+        Waves::Logger.info "#{self.class.basename} on #{host}:#{port} stopped."
+      end
+      
+    end
+  end
+end

data/lib/servers/mongrel.rb

@@ -0,0 +1,13 @@
+module Waves
+  module Servers
+    class Mongrel < Base
+      
+      def call
+        Rack::Handler::Mongrel.run( application, :Host => host, :Port => port ) { |server| yield server if block_given? }
+      end
+      
+      def stop ; @server.stop ; super ; end
+      
+    end
+  end
+end

data/lib/servers/webrick.rb

@@ -0,0 +1,13 @@
+module Waves
+  module Servers
+    class WEBrick < Base
+      
+      def call
+        Rack::Handler::WEBrick.run( application, :Host => host, :Port => port ) { | server | yield server if block_given? }
+      end
+      
+      def stop ; @server.stop ; super ; end
+      
+    end
+  end
+end

data/lib/tasks/gem.rb

@@ -1,4 +1,5 @@
 namespace :gem do
+  
   desc "freeze a gem using gem=<gem name> [version=<gem version>]"
   task :freeze do
     raise "No gem specified" unless gem_name = ENV['gem']

data/lib/tasks/generate.rb

@@ -1,80 +1,85 @@
 namespace :generate do
-
-  desc 'Generate a new controller, with name=<name>'
-  task :controller do |task|
-    name = ENV['name']
-    controller_name = name.camel_case
-    raise "Cannot generate Default yet" if controller_name == 'Default'
-    
-    filename = File.expand_path "controllers/#{name}.rb"
-    if File.exist?(filename)
-      $stderr.puts "#{filename} already exists" 
-      exit
+  
+  # We're declaring these tasks first so we can add descriptions.
+  # The real work is done in the rule, below.
+  desc 'Generate new controller, with name=<name>'
+  task :controller
+  
+  desc 'Generate new view, with name=<name>'
+  task :view
+  
+  desc 'Generate new resource, with name=<name>'
+  task :resource
+  
+  # Rake rules are awesome.  In the main block, t.name is the task name that matched
+  # the regex.  t.source is the string returned by the lambda argument to rule.
+  rule( /controller|view|resource/ => lambda { |task| basetask(task).camel_case << "s" } ) do |t|
+    content = class_template( app_name, t.source, constant_name )
+    name = basetask(t.name) << "s"
+    File.write( filename( name ), content )
+  end
+  
+  desc 'Generate new helper, with name=<name>'
+  task :helper do |task|
+    content = module_template( app_name, "Helpers", constant_name) do
+      "include Waves::Helpers::Default"
     end
+    File.write( filename( "helpers" ), content )
+  end
+  
+end
 
-    controller = <<TEXT
-module #{Waves.application.name}
-  module Controllers
-    class #{controller_name} < Default
+desc "Generate resource, controller, view, and helper with name=<name>"
+task :generate => %w{ generate:resource generate:controller generate:view generate:helper }
 
-    end
-  end
+# Helper methods
+
+def app_name
+  ( ENV['app'] || Dir.pwd.split('/').last ).camel_case
 end
-TEXT
 
-    File.write( filename, controller )
+def constant_name
+  str = ENV['name'].camel_case
+  raise "Cannot generate Default yet" if str == 'Default'
+  str
+end
+
+def filename( kind )
+  path = File.expand_path "#{kind}/#{ENV['name'].snake_case}.rb"
+  if File.exist?(path)
+    $stderr.puts "  Problem encountered:\n  #{path} already exists"
+    exit
   end
-  
-  desc 'Generate new view, with name=<name>'
-  task :view do |task|
-    name = ENV['name']
-    view_name = name.camel_case
-    raise "Cannot generate Default yet" if view_name == 'Default'
-    
-    filename = File.expand_path "views/#{name}.rb"
-    if File.exist?(filename)
-      $stderr.puts "#{filename} already exists" 
-      exit
-    end
+  path
+end
+
+# Rake only pretends to namespace tasks, so to get what we think of as
+# the task name, you must split and grab.
+def basetask(str)
+  str.split(":").last
+end
 
-    view = <<TEXT
-module #{Waves.application.name}
-  module Views
-    class #{view_name} < Default
+def class_template(app_name, place, class_name)
+  str = <<TEXT
+module #{app_name}
+  module #{place}
+    class #{class_name} < Default
 
     end
   end
 end
 TEXT
+end
 
-    File.write( filename, view )
-  end
- 
-  desc 'Generate a new helper, with name=<name>'
-  task :helper do |task|
-    name = ENV['name']
-    helper_name = name.camel_case
-    raise "Cannot generate Default yet" if helper_name == 'Default'
-    
-    filename = File.expand_path "helpers/#{name}.rb"
-    if File.exist?(filename)
-      $stderr.puts "#{filename} already exists" 
-      exit
-    end
-    
-    helper = <<TEXT
-module #{Waves.application.name}
-  module Helpers
-    module #{helper_name}
-      include Waves::Helpers::Default
-      
+# This method expects its block to return something usable as a string.
+def module_template(app_name, place, module_name, &block)
+  str = <<TEXT
+module #{app_name}
+  module #{place}
+    module #{module_name}
+      #{block.call if block}
     end
   end
 end
 TEXT
-
-    File.write( filename, helper )
-  end
-  
-  
-end
+end

data/lib/views/errors.rb

@@ -0,0 +1,49 @@
+require 'helpers/doc_type'
+module Waves
+  module Views
+    class Errors < Waves::Views::Base
+      
+      include Waves::Helpers::DocType
+      
+      def header( title )
+        <<-HTML
+        <head>
+          <title>#{title}</title>
+          <style>
+            body { background: #933; padding: 20px; font-family: verdana, sans-serif; }
+            h1 { font-size: 60px; font-weight: bold; }
+            p { font-size: 24px; }
+          </style>
+        </head>
+        HTML
+      end
+    
+      def not_found_404
+        DOCTYPES[ :html4_transitional ]
+        <<-HTML
+        <html>
+          #{ header( '404: Not Found' ) }
+          <body>
+            <h1>404</h1>
+            <p>That URL does not exist on this server.</p>
+          </body>
+        </html>
+        HTML
+      end
+    
+      def server_error_500
+        DOCTYPES[ :html4_transitional ]
+        <<-HTML
+        <html>
+          #{ header( '500: Server Error' ) }
+          <body>
+            <h1>404</h1>
+            <p>Internal server error. Sorry, but your request could not be processed.</p>
+          </body>
+        </html>
+        HTML
+      end
+
+    end
+  end
+end

data/lib/views/mixin.rb

@@ -1,110 +1,62 @@
 module Waves
 
-  # Views in Waves are ultimately responsible for generating the response body. Views mirror controllers - both have full access to the request and response, and both may modify the response and even short-circuit the request processing and return a result by calling redirect or calling Response#finish.
-  #
-  # Views, like controllers, are classes with methods that are invoked by a mapping block (see Waves::Mapping). View instance methods take an assigns hash that are typically converted into instance variables accesible from within a template.
-  #
-  # Like controllers, a default implementation is provided by the +waves+ command when you first create your application. This default can be overridden to change the behaviors for all views, or you can explicitly define a View class to provide specific behavior for one view.
-  #
-  # The default implementation simply determines which template to render and renders it, returning the result as a string. This machinery is provided by the View mixin, so it is easy to create your own View implementations.
-  #
-  # = Templates
-  #
-  # Although you won't typically need to modify or define View classes, you will often create and modify templates. Templates can be evaluated using any registered Renderer. Two are presently packaged with Waves: Markaby and Erubis. Templates have access to the assigns hash passed to the view method as instance variables. These can be explicitly defined by the mapping file or whomever is invoking the view.
-  #
-  # *Example*
-  #
-  #   # Find the story named 'home' and pass it as @story into the "story/show" template
-  #   use( :story ) | controller { find( 'home' ) } | view { |x| show( :story => x ) }
-  #
-  # = Helpers
-  #
-  # Helper methods can be defined for any view template by simply defining them within the default Helper module in <tt>helpers/default.rb</tt> of the generated application. Helpers specific to a particular View class can be explicitly defined by creating a helper module that corresponds to the View class. For examples, for the +User+ View class, you would define a helper module in <tt>user.rb</tt> named +User+.
-  #
-  # The default helper class initially includes a wide-variety of helpers, including helpers for layouts, Textile formatting, rendering forms, and nested views, as well as helpers for accessing the request and response objects. More helpers will be added in future releases, but in many cases, there is no need to include all of them in your application.
-  #
-  # = Layouts
-  #
-  # Layouts are defined using the +Layout+ view class, and layout templates are placed in the +layout+ directory of the +templates+ directory. Layouts are explicitly set within a template using the +layout+ method.
-  #
-  # *Example*
-  #
-  #   layout :default, :title => @story.title do
-  #     h1 @story.title
-  #     textile @story.content
-  #   end
-  #
-  #
-  # The layout method takes a name and an assigns hash that will be available within the layout template as instance variables. In this example, <tt>@title</tt> will be defined as <tt>@story.title</tt> within the layout template named 'default.'
-  #
-  # Any number of layouts may be included within a single view, and layouts may even be nested within layouts. This makes it possible to create large numbers of highly structured views that can be easily changed with minimal effort. For example, you might specify a layout associated with form elements. By incorporating this into your views as a +layout+ template, you can make changes across all your forms by changing this single template.
-  #
-  # = Nested Views
-  #
-  # It is easy to include one view inside another. A common use for this is to define one set of templates for reusable content 'fragments' (somewhat akin to partials in Rails) and another set that incorporate these fragments into specific layouts. Including a view from within another view is done, logically enough, using the +view+ method.
-  #
-  # *Example*
-  #
-  #   # include the summary view for Story
-  #   view :story, :summary, :story => @story
-  #
-  # = Request And Response Objects
-  #
-  # As always, the request and response objects, and a wide-variety of short-cut methods, are available within view templates via the Waves::ResponseMixin.
-  #
-
   module Views
 
-    class NoTemplateError < Exception ; end
-
-    # A class method that returns the known Renderers, which is any module that is defined within Waves::Renderers and includes the Renderers::Mixin. You can define new Renderers simply be reopening Waves::Renderers and defining a module that mixes in Renderers::Mixin.
-    def Views.renderers
-      return [] if Renderers.constants.nil?
-      Renderers.constants.sort.inject([]) do |rx,cname|
-        ( Module === (c=Renderers.const_get(cname)) &&
-          c < Renderers::Mixin ) ? ( rx << c ) : rx
+    # A class method that returns the known Renderers, which is any module that is defined within Waves::Renderers and includes the Renderers::Mixin.
+    # You can define new Renderers simply be reopening Waves::Renderers and defining a module that mixes in Renderers::Mixin.
+    def self.renderers ; @renderers ||= [] ; end
+    
+    def self.renderer_for(path)
+      @renderers.find do |renderer|
+        File.extname( path ) == ".#{renderer::Extension}" or File.exists?( renderer.filename( path ) )
       end
     end
+    
+    def self.render( path, assigns = {} )
+      template = Views.renderer_for(path) 
+      raise NoTemplateError.new( path ) if template.nil?
+      template.render( path, assigns )
+    end
 
-    # The View mixin simply sets up the machinery for invoking a template, along with methods for accessing the request context and the standard interface for invoking a view method.
+    class NoTemplateError < Exception # :nodoc:
+    end
+
+    # The View mixin simply sets up the machinery for invoking a template, along with methods for accessing
+    # the request assigns and the standard interface for invoking a view method.
     module Mixin
 
       attr_reader :request
 
       include Waves::ResponseMixin
 
-      def self.included( c )
-        def c.process( request, *args, &block )
+      def self.included( target )
+        def target.process( request, *args, &block )
           self.new( request ).instance_exec( *args, &block )
         end
       end
 
-      def initialize( request )
-        @request = request
-        @layout = :default
-      end
+      def initialize( request ) ; @request = request ; @layout = :default ; end
 
       # Return the first renderer for which a template file can be found.
       # Uses Renderers::Mixin.filename to construct the filename for each renderer.
-      def renderer(path)
-        Views.renderers.find do |renderer|
-          File.exists?( renderer.filename( path ) )
-        end
+      def renderer(path) ; Views.renderer_for( :templates / path) ; end
+
+      # Render the template found in the directory named after this view (snake cased, of course)
+      # E.g. App::Views::Gnome.new.render( "stink" ) would look for templates/gnome/stink.<ext>
+      def render( path, assigns = {} )
+        qpath = "#{self.class.basename.snake_case}/#{path}"
+        Waves.log.debug "Rendering template: #{qpath}"
+        Views.render( :templates / qpath, assigns.merge!( :request => request ))
       end
 
-      def render( path, context = {} )
-        context.merge!( :request => request )
-        template = renderer( path ) || renderer( :generic / File.basename(path) )
-        raise NoTemplateError.new( path ) if template.nil?
-        template.render( path, context )
-      end
-
-      def method_missing(name,*args)
-        render( "/#{self.class.basename.snake_case}/#{name}", *args )
-      end
+      # Render the template with the name of the missing method.
+      def method_missing(name,*args) ; render( name, *args ) ; end
 
     end
 
+    class Base ; include Mixin ; end
+
   end
+  
 
 end