merb 0.4.1 → 0.4.2

data/lib/merb/core_ext/numeric.rb

@@ -9,7 +9,7 @@ class Numeric
   # after the number:
   #   1.5.to_currency nil, ",", ".", "$USD" #=> "1.50$USD"
   #   67_000.5.to_currency nil, ".", ",", "DM" #=> "67.000,50DM"
-  def to_currency(pre_symbol='$', thousands=',', decimal='.', post_symbol=nil) #:nodoc:
+  def to_currency(pre_symbol='$', thousands=',', decimal='.', post_symbol=nil)
     "#{pre_symbol}#{("%.2f" % self ).gsub(".", decimal).gsub(/(\d)(?=(?:\d{3})+(?:$|[\\#{decimal}]))/,"\\1#{thousands}")}#{post_symbol}"
   end
 

data/lib/merb/core_ext/string.rb

@@ -2,7 +2,10 @@ require 'strscan'
 
 class String
   class InvalidPathConversion < Exception; end
-  
+
+  # Escapes any characters in the string that would have special meaning in a 
+  # regular expression.
+  #   $ "\*?{}.".escape_regexp #=> "\\*\\?\\{\\}\\."
   def escape_regexp
     Regexp.escape self
   end
@@ -17,6 +20,8 @@ class String
     split('_').map{|e| e.capitalize}.join
   end
   
+  # "merb/core_ext/string" #=> "Merb::CoreExt::String"
+  # 
   # About 50% faster than string.split('/').map{ |s| s.camel_case }.join('::')
   def to_const_string
     new_string = ""
@@ -33,24 +38,16 @@ class String
   end
 
   # Concatenates a path
+  #   $ "merb"/"core_ext" #=> "merb/core_ext"
   def /(o)
     File.join(self, o.to_s)
   end
   
   # Takes lines of text, removes any indentation, and
   # adds +indentation+ number of spaces to each line
+  #   $ "  Hello\n Bob\nHow are you?".indent(3) 
+  #   #=> "   Hello\n   Bob\n   How are you?"
   def indent(indentation)
-    lines = to_a
-    initial_indentation = lines.first.scan(/^(\s+)/).flatten.first
-    lines.map do |line|
-      if initial_indentation.nil?
-        " " * indentation + line
-      elsif line.index(initial_indentation) == 0
-        " " * indentation + line[initial_indentation.size..-1]
-      else
-        " " * indentation + line
-      end
-    end.join
+    match(/\s*/) && gsub(/^\s{0,#{$&.length}}/, " " * indentation)
   end
-  
 end

data/lib/merb/dispatcher.rb

@@ -25,9 +25,9 @@ module Merb
         MERB_LOGGER.info("Cookies: #{request.cookies.inspect}")
         # user friendly error messages
         if request.route_params.empty?
-          raise ControllerExceptions::NotFound, "No routes match the request"
+          raise ControllerExceptions::BadRequest, "No routes match the request"
         elsif request.controller_name.nil?
-          raise ControllerExceptions::NotFound, "Route matched, but route did not specify a controller" 
+          raise ControllerExceptions::BadRequest, "Route matched, but route did not specify a controller" 
         end
         MERB_LOGGER.debug("Routed to: #{request.route_params.inspect}")
         # set controller class and the action to call

data/lib/merb/exceptions.rb

@@ -136,6 +136,7 @@ module Merb
       class TemporaryRedirect           < Merb::ControllerExceptions::Redirection; STATUS = 307; end
     class ClientError                   < Merb::ControllerExceptions::Base; end
       class BadRequest                  < Merb::ControllerExceptions::ClientError; STATUS = 400; end
+        class MultiPartParseError       < Merb::ControllerExceptions::BadRequest; end
       class Unauthorized                < Merb::ControllerExceptions::ClientError; STATUS = 401; end
       class PaymentRequired             < Merb::ControllerExceptions::ClientError; STATUS = 402; end
       class Forbidden                   < Merb::ControllerExceptions::ClientError; STATUS = 403; end
@@ -162,7 +163,8 @@ module Merb
       class ServiceUnavailable          < Merb::ControllerExceptions::ServerError; STATUS = 503; end
       class GatewayTimeout              < Merb::ControllerExceptions::ServerError; STATUS = 504; end
       class HTTPVersionNotSupported     < Merb::ControllerExceptions::ServerError; STATUS = 505; end
-      class InternalServerError         < Merb::ControllerExceptions::ServerError; STATUS = 500
+      class InternalServerError         < Merb::ControllerExceptions::ServerError; 
+        STATUS = 500
         DEFAULT_TEMPLATE = ::Merb::Dispatcher::DEFAULT_ERROR_TEMPLATE
       
         def initialize(exception = nil)

data/lib/merb/logger.rb

@@ -17,6 +17,7 @@ module Merb
     def initialize(log, level = DEBUG)
       @level = level
       @buffer = []
+      @aio = false
       if log.respond_to?(:write)
         @log = log
       elsif File.exist?(log)
@@ -27,16 +28,24 @@ module Merb
         @log.sync = true
         @log.write("# Logfile created on %s\n" % [Time.now.to_s])
       end
+      if !MERB_ENV.match(/development|test/) && 
+         !RUBY_PLATFORM.match(/java|mswin/) &&
+         !(@log == STDOUT) &&
+          @log.respond_to?(:write_nonblock)
+        @aio = true
+      end
     end
-
+    
     def flush
-      if @log.respond_to?(:write_nonblock)
-        @log.write_nonblock @buffer.slice!(0..-1).to_s unless @buffer.size == 0
-      else
-        @log.write @buffer.slice!(0..-1).to_s unless @buffer.size == 0
+      unless @buffer.size == 0
+        if @aio
+          @log.write_nonblock(@buffer.slice!(0..-1).to_s)
+        else
+          @log.write(@buffer.slice!(0..-1).to_s)
+        end
       end
     end
-
+    
     def close
       flush
       @log.close if @log.respond_to?(:close)

data/lib/merb/mail_controller.rb

@@ -245,9 +245,25 @@ module Merb
 
     # A convenience method that creates a blank copy of the MailController and runs
     # dispatch_and_deliver on it.
-    def self.dispatch_and_deliver(method, mail_params)
-      new({}).dispatch_and_deliver method, mail_params
+    def self.dispatch_and_deliver(method, mail_params, send_params = {})
+      new(send_params).dispatch_and_deliver method, mail_params
     end
     
+    protected
+    def route
+      @base_controller.route if @base_controller
+    end
+
+    private
+    # This method is here to overwrite the one in the general_controller mixin
+    # The method ensures that when a url is generated with a hash, it contains a controller
+    def get_controller_for_url_generation(opts)
+      puts @base_controller.params[:controller] if @base_controller
+      controller = opts[:controller] || ( @base_controller.params[:controller] if @base_controller)
+       raise "No Controller Specified for url()" unless controller
+       controller
+    end
+    
+    
   end
 end

data/lib/merb/mailer.rb

@@ -53,7 +53,7 @@ module Merb
     def net_smtp
       Net::SMTP.start(config[:host], config[:port].to_i, config[:domain], 
                       config[:user], config[:pass], config[:auth]) { |smtp|
-        smtp.send_message(@mail.to_s, @mail.from.first, @mail.to)
+        smtp.send_message(@mail.to_s, @mail.from.first, @mail.to.to_s.split(/[,;]/))
       }
     end
     

data/lib/merb/mixins/controller.rb

@@ -1,201 +1,32 @@
 module Merb
+  # Module that is mixed in to all implemented controllers.
   module ControllerMixin
     
-    # Returns a URL according to the defined route.  Accepts the path and
-    # an options hash.  The path specifies the route requested.  The options 
-    # hash fills in the dynamic parts of the route.
+    # Renders the block given as a parameter using chunked
+    # encoding.
     #
-    # Merb routes can often be one-way; if they use a regex to define
-    # the route, then knowing the controller & action won't be enough
-    # to reverse-generate the route.  However, if you use the default
-    # /controller/action/id?query route, +default_route+ can generate
-    # it for you.
+    # ==== Examples
     #
-    # For easy reverse-routes that use a Regex, be sure to also add
-    # a name to the route, so +url+ can find it.
-    # 
-    # Nested resources such as:
-    #  r.resources :blogposts do |post|
-    #    post.resources :comments
-    #  end
-    #
-    # Provide the following routes:
-    #   [:blogposts, "/blogposts"]
-    #   [:blogpost, "/blogposts/:id"]
-    #   [:edit_blogpost, "/blogposts/:id/edit"]
-    #   [:new_blogpost, "/blogposts/new"]
-    #   [:custom_new_blogpost, "/blogposts/new/:action"]
-    #   [:comments, "/blogposts/:blogpost_id/comments"]
-    #   [:comment, "/blogposts/:blogpost_id/comments/:id"]
-    #   [:edit_comment, "/blogposts/:blogpost_id/comments/:id/edit"]
-    #   [:new_comment, "/blogposts/:blogpost_id/comments/new"]
-    #   [:custom_new_comment, "/blogposts/:blogpost_id/comments/new/:action"]
-    #
-    # Examples:
-    #
-    #  @post = Post.find(1)
-    #  @comment = @post.comments.find(1)
-    #
-    #  url(:blogposts)                                    # => /blogposts
-    #  url(:new_post)                                     # => /blogposts/new
-    #  url(:blogpost, @post)                              # => /blogposts/1
-    #  url(:edit_blogpost, @post)                         # => /blogposts/1/edit
-    #  url(:custom_new_blogpost, :action => 'alternate')  # => /blogposts/new/alternate
-    #   
-    #  url(:comments, :blogpost => @post)         # => /blogposts/1/comments
-    #  url(:new_comment, :blogpost => @post)      # => /blogposts/1/comments/new
-    #  url(:comment, @comment)                    # => /blogposts/1/comments/1
-    #  url(:edit_comment, @comment)               # => /blogposts/1/comments/1/edit
-    #  url(:custom_new_comment, :blogpost => @post)
-    #
-    #  url(:page => 2)                            # => /posts/show/1?page=2
-    #  url(:new_post, :page => 3)                 # => /posts/new?page=3
-    #  url('/go/here', :page => 3)                # => /go/here?page=3
-    #
-    #  url(:controller => "welcome")              # => /welcome
-    #  url(:controller => "welcome", :action => "greet")
-    #                                             # => /welcome/greet
-    #
-    def url(route_name = nil, new_params = {})
-      if route_name.is_a?(Hash)
-        new_params = route_name
-        route_name = nil
-      end
-      
-      url = if new_params.respond_to?(:keys) && route_name.nil? &&
-        !(new_params.keys & [:controller, :action, :id]).empty?
-          url_from_default_route(new_params)
-        elsif route_name.nil? && !route.regexp?
-          url_from_route(route, new_params)
-        elsif route_name.nil?
-          request.path + (new_params.empty? ? "" : "?" + params_to_query_string(new_params))
-        elsif route_name.is_a?(Symbol)
-          url_from_route(route_name, new_params)
-        elsif route_name.is_a?(String)
-          route_name + (new_params.empty? ? "" : "?" + params_to_query_string(new_params))
-        else
-          raise "URL not generated: #{route_name.inspect}, #{new_params.inspect}"
-        end
-      url = MerbHandler.path_prefix + url if MerbHandler.path_prefix
-      url
-    end
-
-    def url_from_route(symbol, new_params = {})
-      if new_params.respond_to?(:new_record?) && new_params.new_record?
-        symbol = "#{symbol}".singularize.to_sym
-        new_params = {}
-      end
-      route = symbol.is_a?(Symbol) ? Merb::Router.named_routes[symbol] : symbol
-      raise "URL could not be constructed. Route symbol not found: #{symbol.inspect}" unless route
-      path = route.generate(new_params, params)
-      keys = route.symbol_segments
-      if new_params.is_a? Hash
-        if ext = format_extension(new_params)
-          new_params.delete(:format)
-          path += "." + ext
-        end
-        extras = new_params.reject{ |k, v| keys.include?(k) }
-        path += "?" + params_to_query_string(extras) unless extras.empty?
-      end
-      path
-    end
-    
-    # this is pretty ugly, but it works.  TODO: make this cleaner
-    def url_from_default_route(new_params)
-      query_params = new_params.reject do |k,v|
-        [:controller, :action, :id, :format].include?(k)
-      end
-      controller = new_params[:controller] || params[:controller]
-      controller = params[:controller] if controller == :current
-      url = "/#{controller}"
-      if new_params[:action] || new_params[:id] ||
-                new_params[:format] || !query_params.empty?
-        action = new_params[:action] || params[:action]
-        url += "/#{action}"
-      end
-      if new_params[:id]
-        url += "/#{new_params[:id]}"
-      end
-      if format = new_params[:format]
-        format = params[:format] if format == :current
-        url += ".#{format}"
-      end
-      unless query_params.empty?
-        url += "?" + params_to_query_string(query_params)
-      end
-      url
-    end
-
-    protected
-
-    # Creates query string from params, supporting nested arrays and hashes.
-    # ==== Example
-    #   params_to_query_string(:user => {:filter => {:name => "quux*"}, :order => ["name"]})
-    #   # => user[filter][name]=quux%2A&user[order][]=name
-    def params_to_query_string(value, prefix = nil)
-      case value
-      when Array
-        value.map { |v|
-          params_to_query_string(v, "#{prefix}[]")
-        } * "&"
-      when Hash
-        value.map { |k, v|
-          params_to_query_string(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
-        } * "&"
-      else
-        "#{prefix}=#{escape(value)}"
-      end
-    end
-    
-    # +format_extension+ dictates when named route urls generated by #url
-    # will have a file-extension. It will return false or the format 
-    # extension to append.
-    #
-    #   url(:post, :id => post, :format => 'xml')
-    #
-    #   generates:
-    #
-    #   /posts/34.xml
-    #
-    # by default NON-HTML urls will be given an extension. it is posible 
-    # to override this behaviour by setting +:use_format_in_urls+ in your 
-    # server config (merb.yml) to either true/false
-    #
-    # +true+  would result in ALL urls (even html) being given extensions
-    #         this is often desirable when you have many formats and dont
-    #         wish to treat .html any differently from 
-    # +false+ would result in NO urls being given extensions, and format
-    #         gets treated just like any other param. leave it unset for 
-    #         the default behavior
-    #
-    def format_extension(new_params={})
-      use_format = Merb::Server.config[:use_format_in_urls]
-      if use_format.nil?
-        prms = params.merge(new_params)
-        use_format = prms[:format] != 'html' && prms[:format]
-      end
-      use_format
-    end
-    
-    # render using chunked encoding
-    # def stream
-    #   prefix = '<p>'
-    #   suffix = "</p>\r\n"
-    #   render_chunked do
-    #     IO.popen("cat /tmp/test.log") do |io|
-    #       done = false
-    #       until done
-    #         sleep 0.3
-    #         line = io.gets.chomp
-    #         if line == 'EOF'
-    #           done = true
-    #         else
-    #           send_chunk(prefix + line + suffix)
+    #   def stream
+    #     prefix = '<p>'
+    #     suffix = "</p>\r\n"
+    #     render_chunked do
+    #       IO.popen("cat /tmp/test.log") do |io|
+    #         done = false
+    #         until done
+    #           sleep 0.3
+    #           line = io.gets.chomp
+    #           
+    #           if line == 'EOF'
+    #             done = true
+    #           else
+    #             send_chunk(prefix + line + suffix)
+    #           end
     #         end
     #       end
     #     end
     #   end
-    # end
+    #
     def render_chunked(&blk)
       headers['Transfer-Encoding'] = 'chunked'
       Proc.new {
@@ -206,6 +37,9 @@ module Merb
       }
     end
     
+    # Returns a +Proc+ that Mongrel can call later, allowing
+    # Merb to release the thread lock and render another request.
+    #
     def render_deferred(&blk)
       Proc.new {
         result = blk.call
@@ -215,25 +49,36 @@ module Merb
       }
     end
     
-    # for use within a render_chunked response
+    # Writes a chunk from render_chunked to the response that
+    # is sent back to the client.
     def send_chunk(data)
       response.write('%x' % data.size + "\r\n")
       response.write(data + "\r\n")
     end
     
-    # redirect to another url It can be like /foo/bar
-    # for redirecting within your same app. Or it can
-    # be a fully qualified url to another site.
+    # Redirects to a URL.  The +url+ parameter can be either 
+    # a relative URL (e.g., +/posts/34+) or a fully-qualified URL
+    # (e.g., +http://www.merbivore.com/+).
+    #
+    # ==== Parameters
+    #
+    # +url+ - URL to redirect to; it can be either a relative or 
+    # fully-qualified URL.
+    #
     def redirect(url)
       MERB_LOGGER.info("Redirecting to: #{url}")
       set_status(302)
-      headers.merge!({'Location'=> url})
-      return ''
+      headers['Location'] = url
+      "<html><body>You are being <a href=\"#{url}\">redirected</a>.</body></html>"
     end
     
-    # pass in a path to a file and this will set the
-    # right headers and let mongrel do its thang and
-    # serve the static file directly.
+    # Sends a file over HTTP.  When given a path to a file, it will set the
+    # right headers so that the static file is served directly.
+    #
+    # ==== Parameters
+    # 
+    # +file+ - Path to file to send to the client.
+    #
     def send_file(file, opts={})
       opts.update(Merb::Const::DEFAULT_SEND_FILE_OPTIONS.merge(opts))
       disposition = opts[:disposition].dup || 'attachment'
@@ -247,6 +92,10 @@ module Merb
       return
     end
     
+    # Streams a file over HTTP.
+    #
+    # ==== Example
+    #
     # stream_file( { :filename => file_name, 
     #                :type => content_type,
     #                :content_length => content_length }) do
@@ -270,15 +119,24 @@ module Merb
     end
     
 
-    # This uses nginx X-Accel-Redirect header to send
-    # a file directly from nginx. See the nginx wiki:
+    # Uses the nginx specific +X-Accel-Redirect+ header to send
+    # a file directly from nginx. For more information, see the nginx wiki:
     # http://wiki.codemongers.com/NginxXSendfile
+    #
+    # ==== Parameters
+    # 
+    # +file+ - Path to file to send to the client.
+    #
     def nginx_send_file(file)
       headers['X-Accel-Redirect'] = File.expand_path(file)
       return
     end  
   
-    # Sets a cookie to be included in the response.
+    # Sets a cookie to be included in the response.  This method is used
+    # primarily internally in Merb.
+    #
+    # If you need to set a cookie, then use the +cookies+ hash.
+    #
     def set_cookie(name, value, expires)
       (headers['Set-Cookie'] ||='') << (Merb::Const::SET_COOKIE % [
         name.to_s, 
@@ -288,35 +146,13 @@ module Merb
       ])
     end
     
-    # Marks a cookie as deleted. The cookie is given an expires stamp in 
-    # the past.
+    # Marks a cookie as deleted and gives it an expires stamp in 
+    # the past.  This method is used primarily internally in Merb.
+    #
+    # Use the +cookies+ hash to manipulate cookies instead.
+    #
     def delete_cookie(name)
       set_cookie(name, nil, Merb::Const::COOKIE_EXPIRED_TIME)
     end
-  
-    # creates a random token like:
-    # "b9a82e011694cc13a4249731b9e83cea" 
-    def make_token
-      require 'digest/md5'
-      Digest::MD5.hexdigest("#{inspect}#{Time.now}#{rand}")
-    end  
-    
-
-    def escape_xml(obj)
-      obj.to_s.gsub(/[&<>"']/) { |s| Merb::Const::ESCAPE_TABLE[s] }
-    end
-    alias h escape_xml
-    alias html_escape escape_xml
-  
-    # does url escaping
-    def escape(s)
-      Mongrel::HttpRequest.escape(s)
-    end
-  
-    # does url unescaping
-    def unescape(s)
-      Mongrel::HttpRequest.unescape(s)
-    end
-  
   end
 end