dyoder-waves 0.7.3

data/lib/dispatchers/base.rb

@@ -0,0 +1,52 @@
+module Waves
+
+  module Dispatchers
+
+    class NotFoundError < Exception ; end
+
+    class Redirect < Exception
+      attr_reader :path, :status
+      def initialize( path, status = '302' )
+        @path = path
+        @status = status
+      end
+    end
+
+    # The Base dispatcher simply makes it easier to write dispatchers by inheriting
+    # from it. It creates a Waves request, ensures the request processing is done
+    # within a mutex, benchmarks the request processing, logs it, and handles common
+    # exceptions and redirects. Derived classes need only process the request within
+    # their +safe+ method, which takes a Waves::Request and returns a Waves::Response.
+
+    class Base
+
+      # Like any Rack application, Waves' dispatchers must provide a call method
+      # taking an +env+ parameter.
+      def call( env )
+        Waves::Application.instance.synchronize do
+          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
+
+      # Called by event driven servers like thin and ebb. Return true if
+      # the server should run the request in a separate thread.
+      def deferred?( env )
+        Waves::Application.instance.mapping.threaded?( env )
+      end
+
+    end
+
+  end
+
+end

data/lib/dispatchers/default.rb

@@ -0,0 +1,67 @@
+module Waves
+
+  module Dispatchers
+
+    #
+    # The default dispatcher essentially checks the application's mapping to see
+    # what to do with the request URL. It checks before and after filters (wrap
+    # filters are just a combination of both) as well as path and url mappings.
+    #
+    # The default dispatcher also attempts to set the content type based on the
+    # MIME type implied by any file extension used in the request URL using Mongrel's
+    # MIME types YAML file.
+    #
+    # You can write your own dispatcher and use it in your application's configuration
+    # file. By default, they use the default dispatcher, like this:
+    #
+    #   application do
+    #     use Rack::ShowExceptions
+    #     run Waves::Dispatchers::Default.new
+    #   end
+    #
+
+    class Default < Base
+
+      # All dispatchers using the Dispatchers::Base to provide thread-safety, logging, etc.
+      # must provide a +safe+ method to handle creating a response from a request.
+      # Takes a Waves::Request and returns a Waves::Reponse
+      def safe( request  )
+
+        begin
+          response = request.response
+
+          Waves::Application.instance.reload if Waves::Application.instance.debug?
+          response.content_type = Waves::Application.instance.config.mime_types[ request.path ] || 'text/html'
+
+          mapping = Waves::Application.instance.mapping[ request ]
+
+          mapping[:before].each do | block, args |
+            ResponseProxy.new(request).instance_exec(*args,&block)
+          end
+
+          request.not_found unless mapping[:action]
+
+          block, args = mapping[:action]
+          response.write( ResponseProxy.new(request).instance_exec(*args, &block) )
+
+          mapping[:after].each do | block, args |
+            ResponseProxy.new(request).instance_exec(*args,&block)
+          end
+        rescue Exception => e
+          handler = mapping[:handlers].detect do | exception, block, args |
+            e.is_a? exception
+          end
+          if handler
+            ResponseProxy.new(request).instance_exec(*handler[2], &handler[1])
+          else
+            raise e
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/foundations/default.rb

@@ -0,0 +1,28 @@
+require 'layers/orm/sequel'
+module Waves
+  module Foundations
+    module Default
+
+      def self.included( app )
+
+        app.instance_eval do
+
+          include Waves::Layers::Simple
+          include Waves::Layers::DefaultErrors
+          include Waves::Layers::MVC
+          include Waves::Layers::ORM::Sequel
+
+          # Set autoloading from default.rb files
+          #autoinit :Configurations do
+          #  autoload_class true
+          #end
+          
+        end
+        
+        Waves << app
+        
+      end
+    end
+  end
+end
+

data/lib/foundations/simple.rb

@@ -0,0 +1,17 @@
+module Waves
+  module Foundations
+
+    module Simple
+
+      def self.included( app )
+
+        app.instance_eval do
+          include Waves::Layers::Simple
+        end
+        
+        Waves << app
+      end
+    end
+  end
+end
+

data/lib/helpers/common.rb

@@ -0,0 +1,62 @@
+module Waves
+  module Helpers
+
+    # Common helpers are helpers that are needed for just about any Web page. For example,
+    # each page will likely have a layout and a doctype.
+
+    module Common
+
+      DOCTYPES = {
+        :html3 => "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2//EN\">\n",
+        :html4_transitional =>
+          "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" " <<
+           "\"http://www.w3.org/TR/html4/loose.dtd\">\n",
+        :html4_strict =>
+          "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" " <<
+            "\"http://www.w3.org/TR/html4/strict.dtd\">\n",
+        :html4_frameset =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" " <<
+            "\"http://www.w3.org/TR/html4/frameset.dtd\">\n",
+        :xhtml1_transitional =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" " <<
+            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n",
+        :xhtml1_strict =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" " <<
+            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n",
+        :xhtml1_frameset =>
+          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\" " <<
+            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\">\n",
+        :xhtml2 => "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
+      }
+
+      # Invokes a layout view (i.e., a view from the layouts template directory), using
+      # the assigns parameter to define instance variables for the view. The block is
+      # evaluated and also passed into the view as the +layout_content+ instance variable.
+      #
+      # You can define a layout just by creating a template and then calling the
+      # +layout_content+ accessor when you want to embed the caller's content.
+      #
+      # == Example
+      #
+      #   doctype :html4_transitional
+      #   html do
+      #     title @title # passed as an assigns parameter
+      #   end
+      #   body do
+      #     layout_content
+      #   end
+      #
+      def layout( name, assigns = {}, &block )
+        assigns[ :layout_content ] = capture(&block)
+        self << Waves.application.views[:layouts].process( request ) do
+          send( name, assigns )
+        end
+      end
+
+      # The doctype method simply generates a valid DOCTYPE declaration for your page.
+      # Valid options are defined in the +DOCTYPES+ constant.
+      def doctype(type) ; self << DOCTYPES[type||:html4_strict] ; end
+
+    end
+  end
+end

data/lib/helpers/form.rb

@@ -0,0 +1,39 @@
+module Waves
+
+  module Helpers
+
+    # Form helpers are used in generating forms. Since Markaby already provides Ruby
+    # methods for basic form generation, the focus of this helper is on providing templates
+    # to handle things that go beyond the basics. You must define a form template
+    # directory with templates for each type of form element you wish to use. The names
+    # of the template should match the +type+ option provided in the property method.
+    #
+    # For example, this code:
+    #
+    #   property :name => 'blog.title', :type => :text, :value => @blog.title
+    #
+    # will invoke the +text+ form view (the template in +templates/form/text.mab+),
+    # passing in the name ('blog.title') and the value (@blog.title) as instance variables.
+    #
+    module Form
+
+      # This method really is a place-holder for common wrappers around groups of
+      # properties. You will usually want to override this. As is, it simply places
+      # a DIV element with class 'properties' around the block.
+      def properties(&block)
+        div.properties do
+          yield
+        end
+      end
+
+      # Invokes the form view for the +type+ given in the option.
+      def property( options )
+        self << view( :form, options[:type], options )
+      end
+
+
+    end
+
+  end
+
+end

data/lib/helpers/formatting.rb

@@ -0,0 +1,30 @@
+require 'redcloth'
+module Waves
+  module Helpers
+
+    # Formatting helpers are used to convert specialized content, like Markaby or
+    # Textile, into valid HTML. It also provides common escaping functions.
+    module Formatting
+
+      # Escape a string as HTML content.
+      def escape_html(s); Rack::Utils.escape_html(s); end
+
+      # Escape a URI, converting quotes and spaces and so on.
+      def escape_uri(s); Rack::Utils.escape(s); end
+
+      # Treat content as Markaby and evaluate (only works within a Markaby template).
+      # Used to pull Markaby content from a file or database into a Markaby template.
+      def markaby( content ); self << eval( content ); end
+
+      # Treat content as Textile.
+      def textile( content )
+        return if content.nil? or content.empty?
+        ( ::RedCloth::TEXTILE_TAGS  << [ 96.chr, '&8216;'] ).each do |pat,ent|
+          content.gsub!( pat, ent.gsub('&','&#') )
+        end
+        self << ::RedCloth.new( content ).to_html
+      end
+
+    end
+  end
+end

data/lib/helpers/model.rb

@@ -0,0 +1,33 @@
+module Waves
+  module Helpers
+
+    # Model helpers allow you to directly access a model from within a view.
+    # This is useful when creating things like select boxes that need data
+    # from anther model. For example, a Markaby select box for authors might look like:
+    #
+    #   select do
+    #     all(:user).each do |user|
+    #       option user.full_name, :value => user.id
+    #     end
+    #   end
+    #
+    # You could also use these within a view class to keep model-based logic out
+    # of the templates themselves. For example, in the view class you might define
+    # a method called +authors+ that returns an array of name / id pairs. This could
+    # then be called from the template instead of the model helper.
+    #
+    module Model
+
+      # Just like model.all. Returns all the instances of that model.
+      def all( model )
+        Waves.application.models[ model ].all( domain )
+      end
+
+      # Finds a specific instance using the name field
+      def find( model, name )
+        Waves.application.models[ model ][ :name => name ] rescue nil
+      end
+
+    end
+  end
+end

data/lib/helpers/view.rb

@@ -0,0 +1,24 @@
+module Waves
+  module Helpers
+
+    # View helpers are intended to help reuse views from within other views.
+    # Both the +layout+ method in the common helpers and the +property+ method
+    # of the form helpers are specialized instance of this.
+    #
+    # The star of our show here is the +view+ method. This takes a model, view,
+    # and assigns hash (which are converted into instance variables in the target
+    # view) and returns the result of evaluating the view as content in the current
+    # template.
+    module View
+
+      # Invokes the view for the given model, passing the assigns as instance variables.
+      def view( model, view, assigns = {} )
+        self << Waves.application.views[ model ].process( request ) do
+          send( view, assigns )
+        end
+      end
+
+
+    end
+  end
+end

data/lib/layers/default_errors.rb

@@ -0,0 +1,24 @@
+module Waves
+  module Layers
+    module DefaultErrors
+
+      def self.included( app )
+
+        app.instance_eval do
+
+          autoinit 'Configurations::Mapping' do
+            handle(Waves::Dispatchers::NotFoundError) do
+              html = Waves.application.views[:errors].process( request ) do
+                not_found_404( :error => Waves::Dispatchers::NotFoundError )
+              end
+              response.status = '404'
+              response.content_type = 'text/html'
+              response.write( html )
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/layers/simple_errors.rb

@@ -0,0 +1,17 @@
+module Waves
+  module Layers
+    module SimpleErrors
+
+      def self.included( app )
+
+        app.instance_eval do
+
+          autoinit 'Configurations::Mapping' do
+            handle(Waves::Dispatchers::NotFoundError) { response.status = 404 }
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/mapping/mapping.rb

@@ -0,0 +1,252 @@
+module Waves
+
+  # Waves::Mapping is a mixin for defining Waves URI mappings (mapping a request to Ruby code).
+  # Mappings can work against the request url, path, and elements of the request (such as the
+  # request method or accept header). Mappings may also include before, after, or wrap filters
+  # to be run if they match the request. Mappings are created using an appropriate mapping method
+  # along with a URL pattern (a string or regular expression), a hash of constraint options, and
+  # a block, which is the code to run if the pattern matches.
+  #
+  # == 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.
+    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
+
+    # 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 )
+      if path.is_a? Hash
+        params = options
+        options = path
+      else
+        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 => [], :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
+
+      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 = nil;
+    end
+
+    private
+
+    def mapping; @mapping ||= []; end
+
+    def filters; @filters ||= { :before => [], :after => [], :wrap => [] }; end
+
+    def handlers; @handlers ||= []; end
+
+    def match ( request, options, function )
+      return nil unless satisfy( request, options )
+      if options[:path]
+        matches = options[:path].match( request.path )
+      elsif options[:url]
+        matches = options[:url].match( request.url )
+      end
+      return [ function, matches ? matches[1..-1] : nil ]
+    end
+
+    def satisfy( request, options )
+      options.nil? or options.all? do |name,wanted|
+        got = request.send( name ) rescue request.env[  ( name =~ /^rack\./ ) ?
+          name.to_s.downcase : name.to_s.upcase ]
+        ( ( wanted.is_a?(Regexp) && wanted.match( got.to_s ) ) or
+          got.to_s == wanted.to_s ) unless ( wanted.nil? or got.nil? )
+      end
+    end
+  end
+
+end