waves-edge 2009.03.10.13.14

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

@@ -0,0 +1,32 @@
+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']
+
+    require 'rubygems'
+    Gem.manage_gems
+
+    gem = (version = ENV['version']) ?
+      Gem.cache.search(gem_name, "= #{version}").first :
+      Gem.cache.search(gem_name).sort_by { |g| g.version }.last
+
+    version ||= gem.version.version rescue nil
+
+    target_dir = File.join(Waves::Configurations::Default.root, 'gems')
+    mkdir_p target_dir
+    sh "gem install #{gem_name} --version #{version} -i #{target_dir} --no-rdoc --no-ri"
+
+    puts "Unpacked #{gem_name} #{version} to '#{target_dir}'"
+  end
+
+  desc "unfreeze a gem using gem=<gem>"
+  task :unfreeze do
+    raise "No gem specified" unless gem_name = ENV['gem']
+
+    target_dir = File.join(Waves::Configurations::Default.root, 'gems')
+    ENV['GEM_HOME'] = target_dir # no install_dir option for gem uninstall
+
+    sh "gem uninstall #{gem_name}"
+  end
+end

data/lib/tasks/generate.rb

@@ -0,0 +1,85 @@
+namespace :generate do
+  
+  # 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
+
+desc "Generate resource, controller, view, and helper with name=<name>"
+task :generate => %w{ generate:resource generate:controller generate:view generate:helper }
+
+# Helper methods
+
+def app_name
+  ( ENV['app'] || Dir.pwd.split('/').last ).camel_case
+end
+
+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
+  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
+
+def class_template(app_name, place, class_name)
+  str = <<TEXT
+module #{app_name}
+  module #{place}
+    class #{class_name} < Default
+
+    end
+  end
+end
+TEXT
+end
+
+# 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
+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>500</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

@@ -0,0 +1,64 @@
+module Waves
+
+  module Views
+
+    class NoTemplateError < Exception # :nodoc:
+    end
+
+    def self.renderers ; @renderers ||= [] ; end
+    def self.extensions; @extensions ||= renderers.map { |r| r::Extension }; end
+
+    module Mixin
+
+      attr_reader :request
+
+      include Waves::ResponseMixin
+
+      def self.included( target )
+        target.send(:include, Ext) unless target.instance_methods.include?("render")  #Don't redefine render
+        def target.process( request, *args, &block )
+          self.new( request ).instance_exec( *args, &block )
+        end
+      end
+
+      def initialize( request )
+        @request = request
+        @layout = :default
+        clear! if respond_to?(:clear!)  #For Hoshi compatibility
+      end
+
+      def template_file(name)
+        template = "templates/#{self.class.basename.snake_case}/#{name}"
+        extensions = Views.extensions.join(',')
+        # globbing on a {x,y,z} group returns the found files in x,y,z order
+        raise NoTemplateError.new( path ) unless file = Dir["#{template}.{#{extensions}}"].first
+        file
+      end
+
+      # The Views::Mixin::Ext includes functionality that may be incompatible
+      # with some template engines.  It is included when the Mixin is included
+      # unless the target class is incompatible
+      module Ext
+        # 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( name, assigns={})
+          file = template_file(name)
+          ext = File.extname(file).slice(1..-1)
+          Waves.log.debug "Rendering: #{file}"
+          self.send( ext, File.read(file), assigns.merge!( :request => request ))
+        end
+
+        # Render the template with the name of the missing method.
+        # E.g. App::Views::Gnome.new.stink would look for templates/gnome/stink
+        def method_missing(name,*args) ; render( name, *args ) ; end
+      end
+      
+    end
+
+    class Base ; include Mixin ; end
+
+  end
+  
+
+end

data/lib/waves.rb

@@ -0,0 +1,63 @@
+# External Dependencies
+require 'rack'
+require 'daemons'
+
+# a bunch of handy stuff
+require 'extensions/io'
+require 'extensions/symbol' unless Symbol.instance_methods.include? 'to_proc'
+require 'fileutils'
+require 'metaid'
+require 'forwardable'
+require 'date'
+require 'benchmark'
+require 'base64'
+require 'functor'
+require 'filebase'
+require 'filebase/model'
+
+require 'english/style'
+
+# selected project-specific extensions
+require 'ext/integer'
+require 'ext/float'
+require 'ext/string'
+require 'ext/symbol'
+require 'ext/hash'
+require 'ext/tempfile'
+require 'ext/module'
+require 'ext/object'
+require 'ext/kernel'
+
+# waves Runtime
+require 'servers/base'
+require 'servers/webrick'
+require 'servers/mongrel'
+require 'dispatchers/base'
+require 'dispatchers/default'
+require 'runtime/logger'
+require 'runtime/mime_types'
+require 'runtime/runtime'
+require 'runtime/worker'
+require 'runtime/request'
+require 'runtime/response'
+require 'runtime/response_mixin'
+require 'runtime/session'
+require 'runtime/configuration'
+require 'caches/simple'
+
+# waves URI mapping
+require 'matchers/base'
+require 'matchers/accept'
+require 'matchers/content_type'
+require 'matchers/path'
+require 'matchers/query'
+require 'matchers/traits'
+require 'matchers/uri'
+require 'matchers/request'
+require 'matchers/resource'
+require 'resources/paths'
+require 'resources/mixin'
+
+require 'views/mixin'
+require 'views/errors'
+require 'renderers/mixin'

data/samples/blog/Rakefile

@@ -0,0 +1,25 @@
+# Warning:  This file is clobbered when you update your
+# application with the waves script.  Accordingly, you may
+# wish to keep your tasks in .rb or .rake files in lib/tasks
+require 'rubygems'
+waves = [
+    ( WAVES if defined? 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
+require 'runtime/console'
+require 'startup'
+Waves::Console.load( :mode => ENV['mode'] )
+
+# load tasks from waves framework
+require 'layers/orm/providers/sequel/tasks/schema'
+require 'layers/orm/providers/sequel/tasks/generate'
+
+# load tasks from this app's lib/tasks
+Dir[ "lib/tasks/*.{rb,rake}" ].each { |task| require task }
+

data/samples/blog/configurations/default.rb

@@ -0,0 +1,11 @@
+module Blog
+  module Configurations
+    class Default < Waves::Configurations::Default
+      
+      resource Blog::Resources::Map
+      database :adapter => 'sqlite', :database => 'blog.db'
+      server Waves::Servers::Mongrel
+      
+    end
+  end
+end

data/samples/blog/configurations/development.rb

@@ -0,0 +1,29 @@
+module Blog
+
+  module Configurations
+
+    class Development < Default
+
+      reloadable [ Blog ]
+      log :level => :debug
+      host '127.0.0.1'
+      port 4000
+
+      application do
+        use ::Rack::ShowExceptions
+        use ::Rack::Static, 
+          :urls => %w( /css /javascript /favicon.ico ), 
+          :root => 'public'
+        use Rack::Session::Cookie, 
+          :key => 'blog.session', :path => '/',
+          :expire_after => 3.days
+        run ::Waves::Dispatchers::Default.new
+      end
+      
+      server Waves::Servers::Mongrel
+
+    end
+
+  end
+
+end

data/samples/blog/configurations/production.rb

@@ -0,0 +1,26 @@
+module Blog
+
+  module Configurations
+
+    class Production < Default
+      
+      debug false
+      reloadable []
+      log :level => :warn, :output => ( :log / "waves.production" )
+      host '0.0.0.0'
+      port 4000
+
+      application do
+        use ::Rack::Static, 
+          :urls => %w( /css /javascript /favicon.ico ), 
+          :root => 'public'
+        use Rack::Session::Cookie, 
+          :key => 'blog.session', :path => '/',
+          :expire_after => 3.days
+        run ::Waves::Dispatchers::Default.new
+      end
+      
+
+    end
+  end
+end