waves 0.8.2 → 0.9.0

data/lib/runtime/monitor.rb

@@ -1,32 +0,0 @@
-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/runtime.rb

@@ -1,67 +0,0 @@
-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,20 +0,0 @@
-module Waves
-  
-  class Server < Worker
-    
-    def start_tasks
-      @server = config.server.new( application, host, port )
-      @server.start
-    end
-    
-    def stop_tasks ; @server.stop ; end
-    
-    private
-
-    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

data/lib/runtime/session.rb

@@ -1,27 +0,0 @@
-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
-
-    # Create a new session object using the given request. This is not necessarily the
-    # same as constructing a new session. See Rack::Sesssion for more info.
-    def initialize( request )
-      @data = request.rack_request.env['rack.session']
-    end
-    
-    # Return the session data as a hash
-    def to_hash ; @data ; 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
-
-
-  end
-
-end
-

data/lib/runtime/worker.rb

@@ -1,86 +0,0 @@
-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/views/mixin.rb

@@ -1,62 +0,0 @@
-module Waves
-
-  module Views
-
-    # 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
-
-    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( target )
-        def target.process( request, *args, &block )
-          self.new( request ).instance_exec( *args, &block )
-        end
-      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.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
-
-      # 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

data/samples/blog/log/waves.production

@@ -1,3 +0,0 @@
-# Logfile created on Fri Oct 31 09:30:49 -0700 2008 by /
-W, [2008-10-31 09:33:02 #2368]  WARN -- : http://localhost:4000/ not found.
-W, [2008-10-31 09:51:17 #2403]  WARN -- : http://localhost:4000/ not found.

data/templates/classic/resources/map.rb.erb

@@ -1,8 +0,0 @@
-module <%= @name %>
-  module Resources
-    class Map
-      include Waves::Resources::Mixin
-      
-    end
-  end
-end

data/templates/classic/templates/errors/not_found_404.mab

@@ -1,7 +0,0 @@
-style <<-STYLE
-  body { background: #933; padding: 20px; font-family: verdana, sans-serif; }
-  h1 { font-size: 60px; font-weight: bold; margin: 0px; }
-  p { font-size: 24px; margin: 0px; }
-STYLE
-h1 '404'
-p { 'That URL does not exist on this server.' }

data/templates/classic/templates/errors/server_error_500.mab

@@ -1,7 +0,0 @@
-style <<-STYLE
-  body { background: #c93; padding: 20px; font-family: verdana, sans-serif; }
-  h1 { font-size: 60px; font-weight: bold; margin: 0px; }
-  p { font-size: 24px; margin: 0px; }
-STYLE
-h1 '500'
-p %q( Internal server error. Sorry, but your request could not be processed. )

data/templates/classic/templates/layouts/default.mab

@@ -1,14 +0,0 @@
-doctype :html4_strict
-
-html do
-
-  head do
-    title @title
-  end
-
-  body do
-    layout_content
-  end
-
-end
-