waves-stable 0.7.7

data/lib/layers/orm/sequel/migrations/empty.rb.erb

@@ -0,0 +1,9 @@
+class <%= @class_name %> < Sequel::Migration
+
+  def up
+  end
+
+  def down
+  end
+
+end

data/lib/layers/orm/sequel/tasks/generate.rb

@@ -0,0 +1,28 @@
+namespace :generate do
+  
+    desc 'Generate a Sequel model, with name=<name>'
+    task :model do |task|
+      name = ENV['name']
+      model_name = name.camel_case
+      raise "Cannot generate Default yet" if model_name == 'Default'
+
+      filename = File.expand_path "models/#{name}.rb"
+      if File.exist?(filename)
+        $stderr.puts "#{filename} already exists" 
+        exit
+      end
+
+      model = <<TEXT
+module #{Waves.application.name}
+  module Models
+    class #{model_name} < Default
+
+    end
+  end
+end
+TEXT
+
+      File.write( filename, model )
+    end
+  
+end

data/lib/layers/orm/sequel/tasks/schema.rb

@@ -0,0 +1,16 @@
+require "#{File.dirname(__FILE__)}/../../migration"
+
+namespace :schema do
+
+  desc "Create a new Sequel Migration with name=<name>"
+  task :migration do |task|
+    Waves::Layers::ORM.create_migration_for(Sequel)
+  end
+
+  desc "Performs Sequel migrations to version=<version>"
+  task :migrate do |task|
+    version = ENV['version']; version = version.to_i unless version.nil?
+    Sequel::Migrator.apply( Waves.application.database, Waves::Layers::ORM.migration_directory , version )
+  end
+
+end

data/lib/layers/simple.rb

@@ -0,0 +1,32 @@
+module Waves
+  
+  # Waves uses Layers to provide discrete, stackable, interchangeable bundles of functionality.
+  # 
+  # Developers can make use of Layers by including them directly in a Waves application:
+  # 
+  #   module MyApp
+  #     include SomeLayer
+  #   end
+  module Layers
+    
+    # Creates the Configurations namespace and establishes the standard autoload-or-autocreate
+    # rules.
+    module Simple
+      def self.included( app )
+
+        def app.config ; Waves.config ; end
+        def app.configurations ; self::Configurations ; end
+        
+        app.instance_eval { include AutoCode }
+        
+        app.auto_create_module( :Configurations ) do
+          include AutoCode
+          auto_create_class true, Waves::Configurations::Default
+          auto_load :Mapping, :directories => [:configurations]
+          auto_load true, :directories => [:configurations]
+        end
+      end
+    end
+  end
+end
+      

data/lib/layers/simple_errors.rb

@@ -0,0 +1,23 @@
+module Waves
+  module Layers
+    # Configures Waves for minimal exception handling.  
+    # 
+    # For example,
+    # a NotFoundError results in response status of 404, with body text
+    # of "404 Not Found".
+    module SimpleErrors
+
+      def self.included( app )
+
+        app.auto_eval :Configurations do
+          auto_eval :Mapping do
+            handle(Waves::Dispatchers::NotFoundError) do
+               response.status = 404; response.body = "404 Not Found"
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mapping/mapping.rb

@@ -0,0 +1,289 @@
+module Waves
+
+  # Mappings in Waves are the interface between the request dispatcher and your
+  # application code.  The dispatcher matches each request against the mappings
+  # to determine a primary action and to collect sets of before, after, wrap, 
+  # and always actions.  The dispatcher also looks for an exception handler 
+  # registered in the mappings when attempting a rescue.
+  # 
+  # Each mapping associates a block with a set of constraints.  Mappings can be
+  # one of several types:
+  # 
+  # - action (the actual request processing and response)
+  # - handle (exception handling)
+  # - before 
+  # - after
+  # - wrap (registers its block as both a before and after action)
+  # - always (like an "ensure" clause in a rescue)
+  # 
+  # Actions are registered using path, url, or map.  The other types may be 
+  # registered using methods named after the type.
+  # 
+  # 
+  # The available constraints are:
+  # 
+  # - a string or regexp that the path or url must match
+  # - parameters to match against the HTTP request headers and the Rack-specific variables (e.g. 'rack.url_scheme')
+  # - an additional hash reserved for settings not related to the Rack request (e.g. giving Rack handers special instructions for certain requests.  See threaded? )
+  # 
+  # The dispatcher evaluates mapping blocks in an instance of ResponseProxy, 
+  # which provides access to foundational classes of a Waves application (i.e. controllers and views)
+  #
+  # == Examples
+  #
+  #   resource = '([\w\-]+)'
+  #   name = '([\w\-\_\.\+\@]+)'
+  #
+  #   path %r{^/#{resource}/#{name}/?$} do |resource, name|
+  #     "Hello from a #{resource} named #{name.capitalize}."
+  #   end
+  #
+  # In this example, we are using binding regular expressions defined by +resource+
+  # and +name+. The matches are passed into the block as parameters. Thus, this
+  # rule, given the URL '/person/john' will return:
+  #
+  #   Hello from a person named John.
+  #
+  # The given block may simple return a string. The content type is inferred from the request
+  # if possible, otherwise it defaults to +text+/+html+.
+  #
+  #   path '/critters', :method => :post do
+  #     request.content_type
+  #   end
+  #
+  #   /critters # => 'text/html'
+  #
+  # In this example, we match against a string and check to make sure that the request is a
+  # POST. If so, we return the request content_type. The request (and response) objects are
+  # available from within the block implicitly.
+  #
+  # = Invoking Controllers and Views
+  #
+  # You may invoke a controller or view method for the primary application by using the
+  # corresponding methods, preceded by the +use+ directive.
+  #
+  # == Examples
+  #
+  #   path %r{^/#{resource}/#{name}/?$} do |resource, name|
+  #     resource( resource ) do
+  #       controller { find( name ) } |  view { | instance | show( resource => instance ) }
+  #     end
+  #   end
+  #
+  # In this example, we take the same rule from above but invoke a controller and view method.
+  # We use the +resource+ directive and the resource parameter to set the MVC instances we're going
+  # to use. This is necessary to use the +controller+ or +view+ methods. Each of these take
+  # a block as arguments which are evaluated in the context of the instance. The +view+ method
+  # can further take an argument which is "piped" from the result of the controller block. This
+  # isn't required, but helps to clarify the request processing. Within a view block, a hash
+  # may also be passed in to the view method, which is converted into instance variables for the
+  # view instance. In this example, the +show+ method is assigned to an instance variable with the
+  # same name as the resource type.
+  #
+  # So given the same URL as above - /person/john - what will happen is the +find+ method for
+  # the +Person+ controller will be invoked and the result passed to the +Person+ view's +show+
+  # method, with +@person+ holding the value returned.
+  #
+  # Crucially, the controller does not need to know what variables the view depends on. This is
+  # the job of the mapping block, to act as the "glue" between the controller and view. The
+  # controller and view can thus be completely decoupled and become easier to reuse separately.
+  #
+  #   url 'http://admin.foobar.com:/' do
+  #     resource( :admin ) { view { console } }
+  #   end
+  #
+  # In this example, we are using the +url+ method to map a subdomain of +foobar.com+ to the
+  # console method of the Admin view. In this case, we did not need a controller method, so
+  # we simply didn't call one.
+  #
+  # = Mapping Modules
+  #
+  # You may encapsulate sets of related rules into modules and simply include them into your
+  # mapping module. Some rule sets come packaged with Waves, such as PrettyUrls (rules for
+  # matching resources using names instead of ids). The simplest way to define such modules for
+  # reuse is by defining the +included+ class method for the rules module, and then define
+  # the rules using +module_eval+. See the PrettyUrls module for an example of how to do this.
+  #
+  # *Important:* Using pre-packaged mapping rules does not prevent you from adding to or
+  # overriding these rules. However, order does matter, so you should put your own rules
+  # ahead of those your may be importing. Also, place rules with constraints (for example,
+  # rules that require a POST) ahead of those with no constraints, otherwise the constrainted
+  # rules may never be called.
+
+  module Mapping
+
+    # If the pattern matches and constraints given by the options hash are satisfied, run the
+    # block before running any +path+ or +url+ actions. You can have as many +before+ matches
+    # as you want - they will all run, unless one of them calls redirect, generates an
+    # unhandled exception, etc.
+    def before( path, options = {}, &block )
+      if path.is_a? Hash
+        options = path
+      else
+        options[:path] = path
+      end
+      filters[:before] << [ options, block ]
+    end
+
+    # Similar to before, except it runs its actions after any matching +url+ or +path+ actions.
+    # Note that after methods will run even if an exception is thrown during processing.
+    def after( path, options = {}, &block )
+      if path.is_a? Hash
+        options = path
+      else
+        options[:path] = path
+      end
+      filters[:after] << [ options, block ]
+    end
+
+    # Run the action before and after the matching +url+ or +path+ action.
+    def wrap( path, options = {}, &block )
+      if path.is_a? Hash
+        options = path
+      else
+        options[:path] = path
+      end
+      filters[:before] << [ options, block ]
+      filters[:after] << [ options, block ]
+    end
+
+    # Like after, but will run even when an exception is thrown. Exceptions in
+    # always mappings are simply logged and ignored.
+    def always( path, options = {}, &block )
+      if path.is_a? Hash
+        options = path
+      else
+        options[:path] = path
+      end
+      filters[:always] << [ options, block ]
+    end
+
+    # Maps a request to a block. Don't use this method directly unless you know what
+    # you're doing. Use +path+ or +url+ instead.
+    def map( path, options = {}, params = {}, &block )
+      case path
+      when Hash
+        params = options; options = path
+      when String
+        options[:path] = path
+      end
+      mapping << [ options, params, block ]
+    end
+
+    # Match pattern against the +request.path+, along with satisfying any constraints
+    # specified by the options hash. If the pattern matches and the constraints are satisfied,
+    # run the block. Only one +path+ or +url+ match will be run (the first one).
+    def path( pat, options = {}, params = {}, &block )
+      options[:path] = pat; map( options, params, &block )
+    end
+
+    # Match pattern against the +request.url+, along with satisfying any constraints
+    # specified by the options hash. If the pattern matches and the constraints are satisfied,
+    # run the block. Only one +path+ or +url+ match will be run (the first one).
+    def url( pat, options = {}, params = {}, &block )
+      options[:url] = pat; map( options, params, &block )
+    end
+
+    # Maps the root of the application to a block. If an options hash is specified it must
+    # satisfy those constraints in order to run the block.
+    def root( options = {}, params = {}, &block )
+      path( %r{^/?$}, options, params, &block )
+    end
+    
+    # Maps an exception handler to a block.
+    def handle(exception, options = {}, &block )
+      handlers << [exception,options, block]
+    end
+
+    # Maps a request to a block that will be executed within it's
+    # own thread. This is especially useful when you're running
+    # with an event driven server like thin or ebb, and this block
+    # is going to take a relatively long time.
+    def threaded( pat, options = {}, params = {}, &block)
+      params[:threaded] = true
+      map( pat, options, params, &block)
+    end
+
+    # Determines whether the request should be handled in a separate thread. This is  used
+    # by event driven servers like thin and ebb, and is most useful for those methods that
+    # take a long time to complete, like for example upload processes. E.g.:
+    #
+    #   threaded("/upload", :method => :post) do
+    #     handle_upload
+    #   end
+    #
+    # You typically wouldn't use this method directly.
+    def threaded?( request )
+      mapping.find do | options, params, function |
+        match = match( request, options, function )
+        return params[:threaded] == true if match
+      end
+      return false
+    end
+    
+    # Match the given request against the defined rules. This is typically only called
+    # by a dispatcher object, so you shouldn't typically use it directly.
+    def []( request )
+
+      rx = { :before => [], :after => [], :always => [], :action => nil, :handlers => [] }
+
+      ( filters[:before] + filters[:wrap] ).each do | options, function |
+        matches = match( request, options, function )
+        rx[:before] << matches if matches
+      end
+
+      mapping.find do | options, params, function |
+        rx[:action] = match( request, options, function )
+        break if rx[:action]
+      end
+
+      ( filters[:after] + filters[:wrap] ).each do | options, function |
+        matches = match( request, options, function )
+        rx[:after] << matches if matches
+      end
+
+      filters[:always].each do | options, function |
+        matches = match( request, options, function )
+        rx[:always] << matches if matches
+      end
+
+      handlers.each do | exception, options, function |
+        matches = match( request, options, function )
+        rx[:handlers] << matches.unshift(exception) if matches
+      end
+
+      return rx
+    end
+
+    # Clear all mapping rules
+    def clear
+      @mapping = @filters = @handlers = nil;
+    end
+
+    private
+
+    def mapping; @mapping ||= []; end
+
+    def filters; @filters ||= { :before => [], :after => [], :wrap => [], :always => [] }; end
+
+    def handlers; @handlers ||= []; end
+
+    def match ( request, options, function )
+      return nil unless satisfy( request, options )
+      return [ function, nil ] if ( options[:path] == true or options[:url] == true )
+      matches = options[:path].match( request.path ) if options[:path]
+      matches = options[:url].match( request.url ) if options[:url]
+      return [ function, matches ? matches[1..-1] : nil ]
+    end
+
+    def satisfy( request, options )
+      options.nil? or options.all? do |name,wanted|
+        return true if wanted == true
+        got = request.send( name ) rescue request.env[  ( name =~ /^rack\./ ) ? name.to_s.downcase : name.to_s.upcase ]
+        ( ( wanted.is_a?(Regexp) and wanted.match( got.to_s ) ) or got.to_s == wanted.to_s ) unless ( wanted.nil? or got.nil? )
+      end
+    end
+  end
+  
+
+end

data/lib/mapping/pretty_urls.rb

@@ -0,0 +1,96 @@
+module Waves
+  module Mapping
+
+    # A set of pre-packed mapping rules for dealing with pretty URLs (that use names instead
+    # of numbers to identify resources). There are two modules.
+    # - GetRules, which defines all the GET methods for dealing with named resources
+    # - RestRules, which defines add, update, and delete rules using a REST style interface
+    #
+    module PrettyUrls
+
+      #
+      # GetRules defines the following URL conventions:
+      #
+      #   /resources            # => get a list of all instances of resource
+      #   /resource/name        # => get a specific instance of resource with the given name
+      #   /resource/name/editor # => display an edit page for the given resource
+      #
+      module GetRules
+
+        def self.included(target)
+
+          target.module_eval do
+
+            extend Waves::Mapping
+
+            name = '([\w\-\_\.\+\@]+)'; model = '([\w\-]+)'
+
+            # get all resources for the given model
+            path %r{^/#{model}/?$}, :method => :get do | model |
+              resource( model.singular ) { controller { all } | view { |data| list( model => data ) } }
+            end
+
+            # get the given resource for the given model
+            path %r{^/#{model}/#{name}/?$}, :method => :get do | model, name |
+              resource( model ) { controller { find( name ) } | view { |data| show( model => data ) } }
+            end
+
+            # display an editor for the given resource / model
+            path %r{^/#{model}/#{name}/editor/?$}, :method => :get do | model, name |
+              resource( model ) {  controller { find( name ) } | view { |data| editor( model => data ) } }
+            end
+
+          end
+
+        end
+
+      end
+
+      #
+      # RestRules defines the following URL conventions:
+      #
+      #   POST /resources            # => add a new resource
+      #   PUT  /resource/name        # => update the given resource
+      #   DELETE /resource/name      # => delete the given resource
+      #
+      module RestRules
+
+        def self.included(target)
+
+          target.module_eval do
+
+            extend Waves::Mapping
+
+            name = '([\w\-\_\.\+\@]+)'; model = '([\w\-]+)'
+
+            # create a new resource for the given model
+            path %r{^/#{model}/?$}, :method => :post do | model |
+              resource( model.singular ) do
+                controller do 
+                  instance = create
+                  redirect( "/#{model_name}/#{instance.name}/editor" )
+                end
+              end
+            end
+
+            # update the given resource for the given model
+            path %r{^/#{model}/#{name}/?$}, :method => :put do | model, name |
+              resource( model ) { controller { update( name ); redirect( url ) }  }
+            end
+
+            # delete the given resource for the given model
+            path %r{^/#{model}/#{name}/?$}, :method => :delete do | model, name |
+              resource( model ) { controller { delete( name ) } }
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end