waves-edge 2009.03.10.13.14

data/bin/waves

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+# WARNING: This strange preamble might look easy to clean-up, but it is needed
+# to work with older versions of gems (< 1.2).
+
+require 'rubygems'
+
+WAVES = "#{File.dirname(__FILE__)}/.." unless defined? WAVES
+
+waves = [
+  WAVES, ENV['WAVES'], './waves'
+].compact.map { |dir| File.join(dir, 'lib') }.find { |d|
+  File.exist? File.join( d, 'waves.rb' )
+}
+if waves
+  $: << waves
+  waves = File.join( waves, 'waves' )
+else
+  waves = 'waves'
+end
+
+require waves
+
+puts "** Waves #{Waves.version} **"
+
+begin
+  require "commands/#{ARGV.first}"
+rescue LoadError => e
+  require "commands/help"
+end

data/doc/HISTORY

@@ -0,0 +1 @@
+See http://github.com/dyoder/waves/tree/master

data/doc/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007-8 Dan Yoder
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/doc/README

@@ -0,0 +1 @@
+To find out more about Waves, visit our Web site, http://rubywaves.com.

data/doc/VERSION

@@ -0,0 +1 @@
+0.8.2

data/lib/caches/file.rb

@@ -0,0 +1,48 @@
+require 'caches/synchronized'
+
+module Waves
+  module Caches
+
+    class File < Simple
+
+      def initialize( args )
+        raise ArgumentError, ":directory is nil" if args[ :directory ].nil?
+        @directory = args[ :directory ] ; @keys = []
+      end
+
+      def store( key, value )            
+        @keys << key
+        ::File.open( @directory / key, 'w') { |f| Marshal.dump( value, f ) }
+      end
+
+      def delete( key )
+        if @keys.include? key
+          ::File.delete( @directory / key )
+          @keys.delete( key )
+        end
+      end
+
+      def clear
+        @keys.each { |key| delete( key ) }
+      end
+
+      def fetch( key )
+        Marshal.load( ::File.read( @directory / key ) ) if @keys.include?( key )
+      rescue ArgumentError
+        nil
+      end
+      
+    end
+    
+    class SynchronizedFile < Synchronized
+      
+      def initialize( args )
+        super( File.new( args ) )
+      end
+      
+    end
+    
+  end
+end
+
+

data/lib/caches/memcached.rb

@@ -0,0 +1,40 @@
+require 'memcached'
+module Waves
+  module Caches
+    class Memcached < Simple
+
+      def initialize( args )
+        raise ArgumentError, ":servers is nil" if args[ :servers ].nil?
+        @cache = ::Memcached.new( args[ :servers ], args[ :options ] || {} )
+      end
+
+      def store( key,value, ttl = 0, marshal = true )
+        cache = @cache.clone;  cache.add( key.to_s, value, ttl, marshal );  cache.destroy
+      end
+
+      def fetch( key )
+        cache = @cache.clone;  cache.get( key.to_s );  cache.destroy
+      rescue ::Memcached::NotFound => e
+        nil
+      end
+
+      def delete( key )
+        cache = @cache.clone; cache.delete( key.to_s );  cache.destroy
+      end
+
+      def clear
+        cache = @cache.clone;  cache.flush;  cache.destroy
+      end
+
+    end
+    
+    class SynchronizedMemcached < Synchronized
+      
+      def initialize( args )
+        super( Memcached.new( args ) )
+      end
+      
+    end
+
+  end
+end

data/lib/caches/simple.rb

@@ -0,0 +1,25 @@
+module Waves
+
+  module Caches
+    
+    #
+    # This class is more or less here to establish the basic interface for caching and for
+    # lightweight caching that doesn't require a dedicated caching process.
+    #
+    
+    class Simple
+      
+      def initialize( hash = {} ) ; @cache = hash ; end
+      def [](key) ; fetch(key) ; end
+      def []=( key, value ) ; store( key, value ) ; end
+      def exists?( key ) ; fetch(key) == nil ? false : true ; end
+      alias :exist? :exists?
+      def store( key, val ) ; @cache[ key ] = val ; end
+      def fetch( key ) ; @cache[ key ] ; end
+      def delete( key ) ; @cache.delete( key ) ; end
+      def clear ; @cache = {} ; end
+      
+    end
+
+  end
+end

data/lib/caches/synchronized.rb

@@ -0,0 +1,25 @@
+
+module Waves
+
+  module Caches
+    
+    #
+    # This is just a proxy for the real cache, but adds Waves synchronization
+    #
+    
+    class Synchronized
+      
+      def initialize( cache ) ; @cache = cache ; end
+      def [](key) ; @cache.fetch(key) ; end
+      def []=( key, value ) ; @cache.store( key, value ) ; end
+      def exists?( key ) ; @cache.has_key?( key ) ; end
+      alias :exist? :exists?
+      def store( key, val ) ; synchronize { @cache.store( key, value ) }; end
+      def fetch( keys ) ; @cache.fetch( key ) ; end
+      def delete( key ) ; synchronize { @cache.delete( key ) } ; end
+      def clear ; synchronize { @cache.clear } ; end
+      def synchronize( &block ) ; Waves.synchronize( &block ) ; end
+    end
+
+  end
+end

data/lib/commands/console.rb

@@ -0,0 +1,35 @@
+require 'choice'
+
+Choice.options do
+  header 'Run waves in console mode.'
+  header ''
+  option :mode do
+    short '-c'
+    long '--config=CONFIG'
+    desc 'Configuration to use.'
+    desc 'Defaults to development.'
+    cast Symbol
+  end
+  separator ''  
+  option :startup do
+    short '-s'
+    long '--startup'
+    desc 'Startup file to load.'
+    desc 'Defaults to "startup.rb"'
+  end
+  separator ''
+end
+
+require 'runtime/console'
+
+begin
+  console = Waves::Console.load( Choice.choices )
+  Object.send(:define_method, :waves) { console }
+  require 'irb'
+  require 'irb/completion'
+  ARGV.clear
+  Waves.log.info "Runtime console starting ..."
+  IRB.start
+rescue LoadError => e
+  puts e.message
+end

data/lib/commands/generate.rb

@@ -0,0 +1,52 @@
+require 'choice'
+require 'rakegen'
+
+waves = File.expand_path( File.dirname( __FILE__ ) / '..' / '..' )
+orms = Dir[ waves / :lib / :layers / :orm / :providers / '*.rb' ].map { |path| File.basename( path, '.rb' )}
+templates = Dir[ waves / :templates / '*' ].map { |path| File.basename( path ) }
+
+Choice.options do
+  
+  option :help  do
+    long '--help'
+    desc 'Show this message'
+  end
+  
+  option :orm do
+    short '-o'
+    long '--orm=ORM'
+    desc "Select an ORM (currently supported: #{orms * ', '} )"
+    valid orms
+  end
+
+  option :template do
+    short '-t'
+    long '--template=TEMPLATE'
+    desc "Select a template for your app (options: #{templates * ', '})."
+    valid templates
+    default 'classic'
+  end
+
+  option :name, :required => true do
+    short '-n'
+    long '--name'
+    desc "Select a name for the application. Use only letters, numbers, dashes, or underscores."
+    validate /^[\w\d\-]+$/
+  end
+
+end
+
+options = Choice.choices
+
+puts "** Creating new Waves application ..."
+
+# why do i have to do this?
+FileUtils.mkdir( File.expand_path( options.name ) )
+
+generator = Rakegen.new("generate") do |gen|
+  gen.source = waves / :templates / options.template
+  gen.target = File.expand_path( options.name )
+  gen.template_assigns = options.merge( :name => options.name.gsub('-','_').camel_case )
+end.invoke
+
+puts "** Application created!"

data/lib/commands/help.rb

@@ -0,0 +1,5 @@
+puts <<-HELP
+Usage: waves [ generate | server | console ] [ options ]
+Run a waves command with the given options. Use --help with any command to learn
+more about that command. EXAMPLE: waves generate --help
+HELP

data/lib/commands/server.rb

@@ -0,0 +1,68 @@
+require 'choice'
+
+Choice.options do
+  header 'Run a waves application server.'
+  header ''
+  option :port  do
+    short '-p'
+    long '--port=PORT'
+    desc 'Port to listen on.'
+    desc 'Defaults to value given in configuration.'
+    cast Integer
+  end
+  separator ''
+  option :host do
+    short '-h'
+    long '--host=HOST'
+    desc 'Host or IP address of the host to bind.'
+    desc 'Defaults to value given in configuration.'
+  end
+  separator ''
+  option :mode do
+    short '-c'
+    long '--config=CONFIG'
+    desc 'Configuration to use.'
+    desc 'Defaults to development.'
+    cast Symbol
+  end
+  separator ''
+  option :directory do
+    short '-D'
+    long '--dir=DIR'
+    desc 'Directory containing the application.'
+    desc 'Defaults to the current directory.'
+  end
+  separator ''
+  option :daemon do
+    short '-d'
+    long '--daemon'
+    desc 'Run as a daemon.'
+  end
+  separator ''
+  option :turbo do
+    short '-t'
+    long '--turbo'
+    desc 'For thread-safe applications, run without dispatch level mutex.'
+  end
+  separator ''
+  option :debugger do
+    short '-u'
+    long '--debugger'
+    desc 'Enable ruby-debug.'
+  end
+  separator ''
+  option :startup do
+    short '-s'
+    long '--startup=PATH'
+    desc 'Startup file to load.'
+    desc 'Defaults to "startup.rb"'
+  end
+  separator ''
+end
+
+require 'runtime/server'
+begin
+  Waves::Server.run( Choice.choices )
+rescue LoadError => e
+  puts e.message
+end

data/lib/dispatchers/base.rb

@@ -0,0 +1,68 @@
+module Waves
+
+  module Dispatchers
+
+    class NotFoundError < RuntimeError ; end
+    class Unauthorized < RuntimeError; end
+    class BadRequest < RuntimeError; end
+
+    # Redirect exceptions are rescued by the Waves dispatcher and used to set the 
+    # response status and location.
+    class Redirect < SignalException
+      attr_reader :path, :status
+      def initialize( path, status = '302' )
+        @path = path
+        @status = status
+      end
+      def message
+        "location: #{@path} status: #{@status}"
+      end
+    end
+
+    #
+    # Waves::Dispatchers::Base provides the basic request processing structure
+    # for a Rack application. It creates a Waves request, determines whether 
+    # to enclose the request processing in a mutex benchmarks it, logs it, 
+    # and handles redirects. Derived classes need only process the request 
+    # within the +safe+ method, which must take a Waves::Request and return 
+    # a Waves::Response.
+    #
+    
+    class Base
+
+      # As with any Rack application, a Waves dispatcher must provide a call method
+      # that takes an +env+ hash.
+      def call( env )
+        response = if Waves.synchronize? or Waves.debug?
+          Waves.synchronize { Waves.reload ; _call( env )  }
+        else
+          _call( env )
+        end
+      end
+
+      # Called by event driven servers like thin and ebb. Returns true if
+      # the server should run the request in a separate thread.
+      def deferred?( env ) ; Waves.config.resource.new( Waves::Request.new( env ) ).deferred? ; end
+      
+      private
+      
+      def _call( env )
+        request = Waves::Request.new( env )
+        response = request.response
+        t = Benchmark.realtime do
+          begin
+            safe( request )
+          rescue Dispatchers::Redirect => redirect
+            response.status = redirect.status
+            response.location = redirect.path
+          end
+        end
+        Waves::Logger.info "#{request.method}: #{request.url} handled in #{(t*1000).round} ms."
+        response.finish
+      end
+      
+    end
+
+  end
+
+end

data/lib/dispatchers/default.rb

@@ -0,0 +1,25 @@
+module Waves
+
+  module Dispatchers
+
+    class Default < Base
+
+      # Takes a Waves::Request and returns a Waves::Response    
+      def safe( request  )
+        # set a default content type -- this can be overridden by the resource
+        request.response.content_type = request.accept.default
+        resource = Waves.config.resource.new( request )
+        if request.response.body.empty?
+          request.response.write resource.process.to_s
+        else
+          resource.process
+        end
+        # okay, we've handled the request, now write the response unless it was already done
+        request.response.finish
+      end
+
+    end
+
+  end
+
+end