waves-stable 0.7.7 → 2009.3.10

data/bin/waves

@@ -1,84 +1,30 @@
 #!/usr/bin/env ruby
 
-# = Generate or update a Waves application
-# 
-# The +waves+ script generates a new Waves application or updates an existing app.  The script uses {RakeGen}[http://github.com/automatthew/rakegen] for file copies and template processing, and the current version of RakeGen requires you to affirm that you want to clobber each and every file when doing an update.
-#
-# == Usage
-# 
-#   # Generate a Waves app using the default ORM layer, which is currently Sequel
-#   waves /path/to/app  
-#
-#   # Generate an app using the default ORM layer, which is currently Sequel
-#   waves /path/to/app --orm=active_record
-#
-#   # Generate an app that does not include an ORM layer
-#   waves /path/to/app -o none 
+# 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'
-require 'choice'
-require 'rakegen'
 
-
-
-# if we're in the waves source, prepend it to the load path
-waves_lib = File.expand_path( "#{File.dirname(__FILE__)}/../../waves/lib" )
-$:.unshift waves_lib if File.exist?(waves_lib)
-require 'waves'
-
-begin
-  require 'utilities/string'
-rescue LoadError
-  require File.join(File.dirname(__FILE__), '..', 'lib', 'utilities', 'string')
-end
-
-Choice.options do
-  banner 'Usage:  waves path/to/app [-h]'
-  option :help  do
-    long '--help'
-    desc 'Show this message'
-  end
-  
-  option :orm do
-    short '-o'
-    long '--orm=ORM'
-    desc "Select an ORM (e.g. active_record, sequel, none)"
-    default "sequel"
-  end
-  
-end
-
-orm = Choice.choices.orm.snake_case
-orm_require, orm_include = case orm
-when 'sequel'
-  ["require 'layers/orm/sequel'", "include Waves::Layers::ORM::Sequel"]
-when 'active_record'
-  ["require 'layers/orm/active_record'", "include Waves::Layers::ORM::ActiveRecord"]
-when 'none'
-  ['', '# This app was generated without an ORM layer']
+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
 
-app_path = ARGV[0]
-app_name = File.basename(app_path)
-if app_name =~ /[^\w\d_]/
-  raise ArgumentError, <<-TEXT
-  Unusable name: \"#{app_name}\"
-  Application names may contain only letters, numbers, and underscores."
-TEXT
-end
+require waves
 
-template = "#{WAVES}/app"
+puts "** Waves #{Waves.version} **"
 
-generator = Rakegen.new("waves:app") do |gen|
-  gen.source = template
-  gen.target = app_path
-  gen.template_assigns = {:name => app_name.camel_case, :orm_require => orm_require, :orm_include => orm_include }
-  gen.executables = %w{ bin/waves-console  bin/waves-server}
+begin
+  require "commands/#{ARGV.first}"
+rescue LoadError => e
+  require "commands/help"
 end
-
-puts "** Creating new Waves application ..."
-
-Rake::Task["waves:app"].invoke
-
-puts "** Application created!"
-

data/doc/HISTORY

@@ -1,44 +1 @@
-0.7.7
-- ActiveRecord ORM layer
-- base controller helpers that rely on a particular ORM are now defined in the ORM layers
-- Sequel requires moved into the self.included block, to help with the mem footprint
-- rake generate:model reappeared
-- rake waves:freeze and waves:unfreeze
-- Rack::Static declared for /css, /javascript, and /images in generated applications
-- added Lawrence Pit's Haml renderer
-- English inflector pulled into its own layer, in the hope of allowing localization someday
-- utility monkeypatches pulled into modules where possible, for better troubleshooting
-- docs, samples, and verify now actually included in the gem
-- monkeypatch to Tempfile to work around problem with file uploading and Rack.
-0.7.6
-- added metaid as gem dependency
-- Special handling in Windows for interrupts ('cause Windows has trouble with those)
-- Fixed query param destructuring to work for 3+ levels
-0.7.5
-- Foundations and Layers
-- Sequel ORM is now a Layer, instead of being baked in
-- Almost all boilerplate code removed from generated app, by virtue of the Layers refactoring
-- Configuration attribute for selecting a Rack handler
-- Mapping#handle method to register blocks that handle exceptions (e.g. NotFoundError)
-- Blackboard, a very simple shared storaged usable during request processing.
-- Fixed waves script to work when installed as gem (regression)
-- Revised and extended documentation
-- Expanded spec coverage
-0.7.3:
-- Added explicit require for daemons gem
-- Added support for running off source
-- Added support for using SQLite
-- Improved inflection
-- Windows support for waves, waves-server, and waves-console
-0.7.2:
-- Minor bug fixes, improved documentation
-0.7.1:
-- Minor bug fixes, improved documentation
-0.7.0:
-- Minor bug fixes, improved documentation
-0.6.9:
-- Minor bug fixes, improved documentation
-0.6.8:
-- Minor bug fixes, improved documentation
-0.6.7:
-- Initial gem release.
+See http://github.com/dyoder/waves/tree/master

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/{waves-server.rb → server.rb}

@@ -39,6 +39,12 @@ Choice.options do
     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'
@@ -47,9 +53,16 @@ Choice.options do
   separator ''
   option :startup do
     short '-s'
-    long '--startup'
+    long '--startup=PATH'
     desc 'Startup file to load.'
-    desc 'Defaults to "lib/startup.rb"'
+    desc 'Defaults to "startup.rb"'
   end
+  separator ''
+end
+
+require 'runtime/server'
+begin
+  Waves::Server.run( Choice.choices )
+rescue LoadError => e
+  puts e.message
 end
-Waves::Server.run( Choice.choices )

data/lib/dispatchers/base.rb

@@ -2,46 +2,47 @@ module Waves
 
   module Dispatchers
 
-    # A NotFoundError means what you think it means.  The dispatchers included with Waves do not
-    # natively intercept this exception.  Instead an exception handler must be registered in the application
-    # mappings.  The Simple foundation registers a minimal handler, while the Default foundation registers
-    # a slightly fleshier one.
-    class NotFoundError < Exception ; end
+    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 < Exception
+    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.
-    # All other Waves dispatchers should inherit from it.  It creates a Waves request, 
-    # determines whether to enclose the request processing in a mutex, benchmarks it, 
-    # logs it, and handles common exceptions and redirects. Derived classes need only 
-    # process the request within the +safe+ method, which must take a Waves::Request and return a Waves::Response.
-
+    #
+    # 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+ parameter.
+      # that takes an +env+ hash.
       def call( env )
-        if Waves.config.synchronize?
-          Waves::Application.instance.synchronize { _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, as determined by
-      # Configurations::Mapping#threaded?
-      def deferred?( env )
-        Waves::Application.instance.mapping.threaded?( env )
-      end
+      # the server should run the request in a separate thread.
+      def deferred?( env ) ; Waves.config.resource.new( Waves::Request.new( env ) ).deferred? ; end
       
       private
       
@@ -59,7 +60,7 @@ module Waves
         Waves::Logger.info "#{request.method}: #{request.url} handled in #{(t*1000).round} ms."
         response.finish
       end
-
+      
     end
 
   end