dyoder-waves 0.7.7 → 0.8.0

data/bin/waves

@@ -1,66 +1,29 @@
 #!/usr/bin/env ruby
-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']
-end
+# WARNING: This strange preamble might look easy to clean-up, but it is needed
+# to work with older versions of gems (< 1.2).
 
-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 'rubygems'
 
-template = "#{WAVES}/app"
+WAVES = "#{File.dirname(__FILE__)}/.." unless defined? WAVES
 
-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}
+waves = [
+    WAVES, ENV['WAVES'], './waves'
+].compact.map { |dir| File.join(dir, 'lib') }.find( &File.method( :directory? ) )
+if waves
+    $: << waves
+    waves = File.join( waves, 'waves' )
+else
+    waves = 'waves'
 end
+require waves
 
-puts "** Creating new Waves application ..."
 
-Rake::Task["waves:app"].invoke
+puts "** Waves #{Waves.version} **"
 
-puts "** Application created!"
 
+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.0

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 [ gen | start | console ] [ options ]
+Run a waves command with the given options. Use --help with any command to learn
+more about that command. EXAMPLE: waves gen --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,11 +2,9 @@ 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.
@@ -16,32 +14,35 @@ module Waves
         @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