dyoder-waves 0.7.7 → 0.8.0

data/lib/helpers/default.rb

@@ -1,13 +0,0 @@
-module Waves
-  module Helpers
-    module Default
-      attr_reader :request, :content
-      include Waves::ResponseMixin
-      include Waves::Helpers::Common
-      include Waves::Helpers::Formatting
-      include Waves::Helpers::Model
-      include Waves::Helpers::View
-      include Waves::Helpers::Form
-    end
-  end
-end

data/lib/helpers/number_helper.rb

@@ -1,25 +0,0 @@
-module Waves
-  module Helpers
-    module NumberHelper
-
-      # Formats a +number+ with grouped thousands using +delimiter+. You
-      # can customize the format in the +options+ hash.
-      # * <tt>:delimiter</tt>  - Sets the thousands delimiter, defaults to ","
-      # * <tt>:separator</tt>  - Sets the separator between the units, defaults to "."
-      #
-      #  number_with_delimiter(12345678)      => 12,345,678
-      #  number_with_delimiter(12345678.05)   => 12,345,678.05
-      #  number_with_delimiter(12345678, :delimiter => ".")   => 12.345.678
-      def number_with_delimiter(number, delimiter=",", separator=".")
-        begin
-          parts = number.to_s.split(separator)
-          parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
-          parts.join separator
-        rescue
-          number
-        end
-      end
-
-    end
-  end
-end

data/lib/helpers/tag_helper.rb

@@ -1,58 +0,0 @@
-module Waves
-  module Helpers
-    module TagHelper
-      
-      ESCAPE_TABLE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
-      def h(value)
-        value.to_s.gsub(/[&<>"]/) { |s| ESCAPE_TABLE[s] }
-      end
-      
-      # Returns an empty HTML tag of type +name+ which by default is XHTML 
-      # compliant. Setting +open+ to true will create an open tag compatible 
-      # with HTML 4.0 and below. Add HTML attributes by passing an attributes 
-      # hash to +options+. For attributes with no value like (disabled and 
-      # readonly), give it a value of true in the +options+ hash. You can use
-      # symbols or strings for the attribute names.
-      #
-      #   tag("br")
-      #    # => <br />
-      #   tag("br", nil, true)
-      #    # => <br>
-      #   tag("input", { :type => 'text', :disabled => true }) 
-      #    # => <input type="text" disabled="disabled" />
-      def tag(name, options = nil, open = false)
-        "<#{name}#{tag_options(options) if options}" + (open ? ">" : " />")
-      end
-      
-      # Returns the escaped +html+ without affecting existing escaped entities.
-      #
-      #   escape_once("1 > 2 &amp; 3")
-      #    # => "1 &lt; 2 &amp; 3"
-      def escape_once(html)
-        fix_double_escape(h(html.to_s))
-      end
-      
-      private
-        
-        def tag_options(options)
-          cleaned_options = convert_booleans(options.stringify_keys.reject {|key, value| value.nil?})
-          ' ' + cleaned_options.map {|key, value| %(#{key}="#{escape_once(value)}")}.sort * ' ' unless cleaned_options.empty?
-        end
-        
-        def convert_booleans(options)
-          %w( disabled readonly multiple ).each { |a| boolean_attribute(options, a) }
-          options
-        end
-        
-        def boolean_attribute(options, attribute)
-          options[attribute] ? options[attribute] = attribute : options.delete(attribute)
-        end
-        
-        # Fix double-escaped entities, such as &amp;amp;, &amp;#123;, etc.
-        def fix_double_escape(escaped)
-          escaped.gsub(/&amp;([a-z]+|(#\d+));/i) { "&#{$1};" }
-        end
-        
-    end
-  end
-end

data/lib/helpers/url_helper.rb

@@ -1,77 +0,0 @@
-module Waves
-  module Helpers
-    module UrlHelper
-
-      # Returns the URL for the set of +options+ provided. This takes the 
-      # same options as url_for in action controller. For a list, see the 
-      # documentation for ActionController::Base#url_for. Note that it'll 
-      # set :only_path => true so you'll get the relative /controller/action 
-      # instead of the fully qualified http://example.com/controller/action.
-      #  
-      # When called from a view, url_for returns an HTML escaped url. If you 
-      # need an unescaped url, pass :escape => false in the +options+.
-      def url_for(options = {}, *parameters_for_method_reference)
-        if options.kind_of? Hash
-          options = { :only_path => true }.update(options.symbolize_keys)
-          escape = options.key?(:escape) ? options.delete(:escape) : true
-        else
-          escape = true
-        end
-
-        url = options[:url] #@controller.send(:url_for, options, *parameters_for_method_reference)
-        escape ? html_escape(url) : url
-      end
-
-
-      # Creates a link tag of the given +name+ using a URL created by the set 
-      # of +options+. See the valid options in the documentation for 
-      # ActionController::Base#url_for. It's also possible to pass a string instead 
-      # of an options hash to get a link tag that uses the value of the string as the 
-      # href for the link. If nil is passed as a name, the link itself will become 
-      # the name.
-      #
-      # The +html_options+ will accept a hash of html attributes for the link tag.
-      # It also accepts 3 modifiers that specialize the link behavior. 
-      #
-      # * <tt>:confirm => 'question?'</tt>: This will add a JavaScript confirm 
-      #   prompt with the question specified. If the user accepts, the link is 
-      #   processed normally, otherwise no action is taken.
-      # * <tt>:popup => true || array of window options</tt>: This will force the 
-      #   link to open in a popup window. By passing true, a default browser window 
-      #   will be opened with the URL. You can also specify an array of options 
-      #   that are passed-thru to JavaScripts window.open method.
-      # * <tt>:method => symbol of HTTP verb</tt>: This modifier will dynamically
-      #   create an HTML form and immediately submit the form for processing using 
-      #   the HTTP verb specified. Useful for having links perform a POST operation
-      #   in dangerous actions like deleting a record (which search bots can follow
-      #   while spidering your site). Supported verbs are :post, :delete and :put.
-      #   Note that if the user has JavaScript disabled, the request will fall back 
-      #   to using GET. If you are relying on the POST behavior, your should check
-      #   for it in your controllers action by using the request objects methods
-      #   for post?, delete? or put?.
-      #
-      # You can mix and match the +html_options+ with the exception of
-      # :popup and :method which will raise an ActionView::ActionViewError
-      # exception.
-      #
-      #   link_to "Visit Other Site", "http://www.rubyonrails.org/", :confirm => "Are you sure?"
-      #   link_to "Help", { :action => "help" }, :popup => true
-      #   link_to "View Image", { :action => "view" }, :popup => ['new_window_name', 'height=300,width=600']
-      #   link_to "Delete Image", { :action => "delete", :id => @image.id }, :confirm => "Are you sure?", :method => :delete
-      def link_to(name, options = {}, html_options = nil, *parameters_for_method_reference)
-        if html_options
-          html_options = html_options.stringify_keys
-          # convert_options_to_javascript!(html_options)
-          tag_options = tag_options(html_options)
-        else
-          tag_options = nil
-        end
-
-        url = options.is_a?(String) ? options : self.url_for(options, *parameters_for_method_reference)
-        "<a href=\"#{url}\"#{tag_options}>#{name || url}</a>"
-      end
-
-      
-    end
-  end
-end

data/lib/layers/default_errors.rb

@@ -1,26 +0,0 @@
-module Waves
-  module Layers
-    
-    # Configures Waves to use the templates in app/templates/errors for exception handling
-    module DefaultErrors
-
-      def self.included( app )
-
-        app.auto_eval :Configurations do
-          auto_eval :Mapping do
-            extend Waves::Mapping
-            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.body = html
-            end
-          end
-        end
-        
-      end
-    end
-  end
-end

data/lib/layers/orm/filebase.rb

@@ -1,22 +0,0 @@
-module Waves
-  module Layers
-    module ORM
-      
-      # Work in Progress
-      module Filebase
-        
-        def self.included(app)
-          app.module_eval do
-            auto_eval( :Models ) do
-              auto_eval( true ) { include Filebase::Model[ :db / self.name.snake_case ] }
-            end
-          end
-        end
-        
-      end
-    
-    end
-    
-  end
-  
-end

data/lib/layers/simple.rb

@@ -1,35 +0,0 @@
-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]
-          auto_eval :Mapping do
-            extend Waves::Mapping
-          end
-        end
-      end
-    end
-  end
-end
-      

data/lib/layers/simple_errors.rb

@@ -1,23 +0,0 @@
-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

@@ -1,289 +0,0 @@
-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