merb 0.3.7 → 0.4.0

data/lib/merb/generators/merb_plugin.rb

@@ -0,0 +1,19 @@
+require 'fileutils'
+require 'find'
+
+module Merb
+  
+  class PluginGenerator    
+    def self.run(path)
+      require 'rubygems'
+      require 'rubigen'
+
+      require 'rubigen/scripts/generate'
+      RubiGen::Base.use_application_sources!
+      RubiGen::Scripts::Generate.new.run([path], :generator => 'merb_plugin', :backtrace => true)
+    end  
+
+  end
+        
+end  
+

data/lib/merb/logger.rb

@@ -0,0 +1,65 @@
+module Merb
+
+  class Logger
+    module Severity
+      DEBUG = 0
+      INFO = 1
+      WARN = 2
+      ERROR = 3
+      FATAL = 4
+      UNKNOWN = 5
+    end
+    include Severity
+
+    attr_accessor :level
+    attr_reader :buffer
+    
+    def initialize(log, level = DEBUG)
+      @level = level
+      @buffer = []
+      if log.respond_to?(:write)
+        @log = log
+      elsif File.exist?(log)
+        @log = open(log, (File::WRONLY | File::APPEND))
+        @log.sync = true
+      else
+        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
+        @log.sync = true
+        @log.write("# Logfile created on %s\n" % [Time.now.to_s])
+      end
+    end
+
+    def flush
+      @log.write @buffer.slice!(0..-1).to_s unless  @buffer.size == 0
+    end
+
+    def close
+      flush
+      @log.close if @log.respond_to?(:close)
+      @log = nil
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      return if @level > severity
+      message = (message || (block && block.call) || progname).to_s
+      # If a newline is necessary then create a new message ending with a newline.
+      # Ensures that the original message is not mutated.
+      message = "#{message}\n" unless message[-1] == ?\n
+      @buffer << message
+      message
+    end
+    
+    Severity.constants.each do |severity|
+      class_eval <<-EOT
+        def #{severity.downcase}(message = nil, progname = nil, &block)
+          add(#{severity}, message, progname, &block)
+        end
+       
+        def #{severity.downcase}?
+          #{severity} >= @level
+        end
+      EOT
+    end
+    
+  end
+end

data/lib/merb/{merb_mail_controller.rb → mail_controller.rb}

@@ -1,9 +1,72 @@
-require File.dirname(__FILE__)+'/merb_mailer'
 
 module Merb
+  
+  # Sending mail from a controller involves three steps:
+  #
+  # * Set mail settings in merb_init.rb (Not shown here...see the Mailer docs).
+  # * Create a MailController subclass with actions and templates.
+  # * Call the MailController from another Controller via the send_mail method.
+  #
+  # First, create a file in app/mailers that subclasses Merb::MailController. 
+  # The actions in this controller will do nothing but render mail.
+  #
+  #   # app/mailers/article_mailer.rb
+  #   class ArticleMailer < Merb::MailController
+  # 
+  #     def notify
+  #       @user = params[:user]
+  #       render_mail
+  #     end
+  # 
+  #   end
+  #
+  # You also can access the params hash for values passed with the 
+  # Controller.send_mail method. See also the documentation for 
+  # render_mail to see all the ways it can be called.
+  #
+  # Create a template in a subdirectory of app/mailers/views that corresponds
+  # to the controller and action name. Put plain text and ERB tags here:
+  #
+  #   # app/mailers/views/article_mailer/notify.text.erb
+  #   Hey, <%= @user.name %>,
+  #   
+  #   We're running a sale on dog bones!
+  #
+  # Finally, call the Controller.send_mail method from a standard 
+  # Merb controller.
+  #
+  #   class Articles < Application
+  #
+  #     def index
+  #       @user = User.find_by_name('louie')
+  #
+  #       send_mail(ArticleMailer, :notify, {
+  #         :from => "me@example.com",
+  #         :to => "louie@example.com",
+  #         :subject => "Sale on Dog Bones!"
+  #       }, { :user => @user })
+  #       render
+  #     end
+  #
+  #   end  
+  #
+  # Note: If you don't pass a fourth argument to Controller.send_mail,
+  # the controller's params will be sent to the MailController subclass
+  # as params. However, you can explicitly send a hash of objects that 
+  # will populate the params hash instead. In either case, you must 
+  # set instance variables in the MailController's actions if you 
+  # want to use them in the MailController's views.
+  #
+  # The MailController class is very powerful. You can:
+  #
+  # * Send multipart email with a single call to render_mail.
+  # * Attach files.
+  # * Render layouts and other templates.
+  # * Use any template engine supported by Merb.
+  
   class MailController < AbstractController
    
-    self._template_root = File.expand_path(DIST_ROOT / "app/mailers/views")
+    self._template_root = File.expand_path(self._template_root / "../app/mailers/views")
     class_inheritable_accessor :_mailer_klass
     self._mailer_klass  = Merb::Mailer
     
@@ -18,6 +81,7 @@ module Merb
       @params = params
       @base_controller = controller
       @session = (controller && controller.session) || {}
+      super
     end
     
     def filters_halted
@@ -32,13 +96,13 @@ module Merb
     # default Merb render method.
     #
     # First of all, you'll need to store email files in your
-    # dist/app/mailers/views directory. They should be under a directory that
+    # app/mailers/views directory. They should be under a directory that
     # matches the name of your mailer (e.g. TestMailer's views would be stored
     # under test_mailer).
     #
     # The files themselves should be named action_name.mime_type.extension. For
-    # example, a herb template that should be the HTML part of the email, and
-    # rendered from the "foo" action would be named foo.html.herb.
+    # example, an erb template that should be the HTML part of the email, and
+    # rendered from the "foo" action would be named foo.html.erb.
     #
     # The only mime-types currently supported are "html" and "text", which
     # correspond to text/html and text/plain respectively. All template systems
@@ -91,37 +155,41 @@ module Merb
     #
     #   render_mail :html => :foo, :text => "BAR"
     def render_mail(options = @method)
-      # If the options are not a hash, normalize to an action hash
+      @_missing_templates = false # used to make sure that at least one template was found
+      # # If the options are not a hash, normalize to an action hash
       options = {:action => {:html => options, :text => options}} if !options.is_a?(Hash)
-      # Normalize :html => :sym and :text => :sym to an action hash
-      options[:action] ||= {}
-        options[:action][:html] = options.delete(:html) if options[:html].is_a?(Symbol)
-        options[:action][:text] = options.delete(:text) if options[:text].is_a?(Symbol)
-      options.delete(:action) if options[:action].empty?
-
-      # set type to action or template, if the hash includes :action or :template
-      type = options.keys.find {|x| x.to_s =~ /(action|template)/}
-      # normalize :action/:template => ... to :action/template => {:html => ..., :text => ...}
-      options[type] = {:html => options[type], :text => options[type]} if type && !options[type].is_a?(Hash)
-      for mime_type in [:html, :text]
-        # if action or template, get the template to render. If not, get the string to render. If none
-        # are available, use the default params[:action]
-        renderer = (type && options[type][mime_type] ? options[type][mime_type] : options[mime_type]).to_s
-        # action or template
-        if type && options[type][mime_type]
-          # build the template to render
-          mime_renderer = renderer + ".#{mime_type}" if !(renderer =~ /.#{mime_type}$/)
-          if find_template(type => mime_renderer)
-            @mail.send((mime_type == :html ? "rawhtml=" : "text="), 
-              render(type => mime_renderer, :layout => mimed_layout(mime_type, options[:layout]))) 
-          elsif find_template(type => renderer) && mime_type == :text
-            @mail.text = render(type => renderer, :layout => options[:layout])
+      
+      # Take care of the options
+      use_options = {}
+      opts = options.dup
+      actions = opts.delete(:action) if opts[:action].is_a?(Hash)
+      templates = opts.delete(:template) if opts[:template].is_a?(Hash)
+      
+      # Prepare the options hash for each format
+      # We need to delete anything relating to the other format here
+      # before we try to render the template.
+      [:html, :text].each do |fmt|
+        opts_hash = use_options[fmt] = {}
+        opts_hash[fmt] = opts.delete(fmt)
+        opts_hash[fmt] ||= actions[fmt] if actions && actions[fmt]
+        opts_hash[:tempalte] = templates[fmt] if templates && templates[fmt]
+      end
+      
+      # Send the result to the mailer
+      { :html => "rawhtml=", :text => "text="}.each do |fmt,meth|
+        begin
+          value = render use_options[fmt].merge!(opts).merge!(:clean_context => true, :format => fmt)
+          @mail.send(meth,value) unless value.nil? || value.empty?
+        rescue => e
+          # An error should be logged if no template is found instead of an error raised
+          if @_missing_templates
+            MERB_LOGGER.error(e)
+          else
+            @_missing_templates = true
           end
-        # string to render
-        else
-          @mail.send((mime_type == :html ? "rawhtml=" : "text="), renderer)
         end
       end
+      @mail
     end
     
     # Attaches a file or multiple files to an email. You call this from a
@@ -163,6 +231,8 @@ module Merb
       @mailer         = self.class._mailer_klass.new(mail_params)
       @mail           = @mailer.mail
       @method         = method
+      
+      # dipatch and render use params[:action], so set it
       params[:action] = method
       body            = dispatch method
       if !@mail.html.blank? || !@mail.text.blank? 
@@ -179,22 +249,5 @@ module Merb
       new({}).dispatch_and_deliver method, mail_params
     end
     
-    private
-    def mimed_layout(mime_type, layout = nil)
-      if layout && layout != :application
-        layout_choice = find_template(:layout => layout + ".#{mime_type}") ||
-          find_template(:layout => layout)
-      elsif name = find_template(:layout => self.class.name.snake_case + ".#{mime_type}")
-        layout_choice = name
-      elsif name = find_template(:layout => self.class.name.snake_case)
-        layout_choice = name
-      elsif name = find_template(:layout => "application.#{mime_type}")
-        layout_choice = name
-      else
-        layout_choice = find_template(:layout => "application")
-      end
-      layout_choice = layout_choice.split("/").last.split(".")[0...-1].join(".")
-    end
-    
   end
 end

data/lib/merb/{merb_mailer.rb → mailer.rb}

@@ -11,6 +11,32 @@ class MailFactory
 end
 
 module Merb
+
+  # You'll need a simple config like this in merb_init.rb if you want
+  # to actually send mail:
+  #
+  #   Merb::Mailer.config = {
+  #     :host=>'smtp.yourserver.com',
+  #     :port=>'25',              
+  #     :user=>'user',
+  #     :pass=>'pass',
+  #     :auth=>:plain # :plain, :login, or :cram_md5, default :plain
+  #   }
+  # 
+ 	#   or 
+ 	# 
+ 	#   Merb::Mailer.config = {:sendmail_path => '/somewhere/odd')
+  #   Merb::Mailer.delivery_method = :sendmail
+  #
+  # You could send mail manually like this (but it's better to use
+  # a MailController instead).
+  # 
+  #   m = Merb::Mailer.new :to => 'foo@bar.com',
+  #                        :from => 'bar@foo.com',
+  #                        :subject => 'Welcome to whatever!',
+  #                        :body => partial(:sometemplate)
+  #   m.deliver!                     
+
   class Mailer
     
     class_inheritable_accessor :config, :delivery_method, :deliveries
@@ -18,7 +44,7 @@ module Merb
     self.deliveries = []
     
     def sendmail
-      sendmail = IO.popen("sendmail #{@mail.to}", 'w+')
+      sendmail = IO.popen("#{config[:sendmail_path]} #{@mail.to}", 'w+') 
       sendmail.puts @mail.to_s
       sendmail.close
     end
@@ -50,34 +76,12 @@ module Merb
     end
       
     def initialize(o={})
-      self.config = :sendmail if config.nil?
+      self.config = {:sendmail_path => '/usr/sbin/sendmail'} if config.nil? 
       o[:rawhtml] = o.delete(:html)
-      @mail = returning MailFactory.new() do |m|
-        o.each { |k,v| m.send "#{k}=", v }
-      end
+      m = MailFactory.new()
+      o.each { |k,v| m.send "#{k}=", v }
+      @mail = m
     end
     
   end
 end
-
-=begin
-
-
-Merb::Mailer.config = {
-  :host=>'smtp.yourserver.com',
-  :port=>'25',              
-  :user=>'user',
-  :pass=>'pass',
-  :auth=>:plain # :plain, :login, or :cram_md5, default :plain
-}
-
-Merb::Mailer.delivery_method = :sendmail
-
-m = Merb::Mailer.new :to => 'foo@bar.com',
-                     :from => 'bar@foo.com',
-                     :subject => 'Welcome to whatever!',
-                     :body => partial(:sometemplate)
-m.deliver!                     
-
-
-=end

data/lib/merb/mixins/{basic_authentication_mixin.rb → basic_authentication.rb}

@@ -1,6 +1,6 @@
 module Merb
   
-  module Authentication
+  module AuthenticationMixin
     require 'base64'
     
     def credentials
@@ -13,7 +13,7 @@ module Merb
     
     def authenticated?
       username, password = *credentials
-      username == Merb::Server.basic_auth[:username] and password == Merb::Server.basic_auth[:password]
+      username == Merb::Server.config[:basic_auth][:username] and password == Merb::Server.config[:basic_auth][:password]
     end
     
     def basic_authentication
@@ -26,7 +26,7 @@ module Merb
       set_status(401)
       headers['Content-type'] = 'text/plain'
       headers['Status'] = 'Unauthorized'
-      headers['WWW-Authenticate'] = "Basic realm=\"#{Merb::Server.basic_auth[:domain]}\""
+      headers['WWW-Authenticate'] = "Basic realm=\"#{Merb::Server.config[:basic_auth][:domain]}\""
       return 'Unauthorized'
     end  
       

data/lib/merb/mixins/{controller_mixin.rb → controller.rb}

@@ -4,6 +4,15 @@ module Merb
     # 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.
+    #
+    # 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.
+    #
+    # 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|
@@ -39,123 +48,129 @@ module Merb
     #  url(:edit_comment, @comment)               # => /blogposts/1/comments/1/edit
     #  url(:custom_new_comment, :blogpost => @post)
     #
-    def url(path, o={})
-      ::Merb::Router.generate(path,o)
-    end
-    
-    protected
-    NAME_REGEX = /Content-Disposition:.* name="?([^\";]*)"?/ni.freeze
-    CONTENT_TYPE_REGEX = /Content-Type: (.*)\r\n/ni.freeze
-    FILENAME_REGEX = /Content-Disposition:.* filename="?([^\";]*)"?/ni.freeze
-    CRLF = "\r\n".freeze
-    EOL = CRLF
-    def parse_multipart(request,boundary,env)
-      boundary = "--#{boundary}"
-      paramhsh = {}
-      buf = ""
-      content_length = env['CONTENT_LENGTH'].to_i
-      input = request
-      input.binmode if defined? input.binmode
-      boundary_size = boundary.size + EOL.size
-      bufsize = 16384
-      content_length -= boundary_size
-      status = input.read(boundary_size)
-      raise EOFError, "bad content body"  unless status == boundary + EOL
-      rx = /(?:#{EOL})?#{Regexp.quote(boundary,'n')}(#{EOL}|--)/
-      loop {
-        head = nil
-        body = ''
-        filename = content_type = name = nil
-        read_size = 0
-        until head && buf =~ rx
-          i = buf.index("\r\n\r\n")
-          if( i == nil && read_size == 0 && content_length == 0 )
-            content_length = -1
-            break
-          end
-          if !head && i
-            head = buf.slice!(0, i+2) # First \r\n
-            buf.slice!(0, 2)          # Second \r\n
-            filename = head[FILENAME_REGEX, 1]
-            content_type = head[CONTENT_TYPE_REGEX, 1]
-            name = head[NAME_REGEX, 1]
-            
-            if filename && !filename.empty?    
-              body = Tempfile.new(:Merb)
-              body.binmode if defined? body.binmode
-            end
-            next
-          end
-
-          
-          # Save the read body part.
-          if head && (boundary_size+4 < buf.size)
-            body << buf.slice!(0, buf.size - (boundary_size+4))
-          end
+    #  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
       
-          read_size = bufsize < content_length ? bufsize : content_length
-          if( read_size > 0 )
-            c = input.read(read_size)
-            raise EOFError, "bad content body"  if c.nil? || c.empty?
-            buf << c
-            content_length -= c.size
-          end
+      url = if new_params.respond_to?(:keys) &&
+        !(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
 
-        # Save the rest.
-        if i = buf.index(rx)
-          body << buf.slice!(0, i)
-          buf.slice!(0, boundary_size+2)
-      
-          content_length = -1  if $1 == "--"
-        end
-        
-        if filename && !filename.empty?   
-          body.rewind
-          data = { 
-         	  :filename => File.basename(filename),  
-         	  :content_type => content_type,  
-         	  :tempfile => body, 
-         	  :size => File.size(body) 
-         	}
-        else
-          data = body
+    def url_from_route(symbol, new_params = {})
+      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
-        paramhsh = normalize_params(paramhsh,name,data)
-        break  if buf.empty? || content_length == -1
-      }
-      paramhsh
+        extras = new_params.reject{ |k, v| keys.include?(k) }
+        path += "?" + params_to_query_string(extras) unless extras.empty?
+      end
+      path
     end
     
-    def normalize_params(parms, key, val)
-      case key
-      when /(.+)\[(.+)\]\[\]$/
-        parms[$1] ||= {}
-        parms[$1] = normalize_params(parms[$1], "#{$2}[]", val)
-      when /(.+)\[(.+)\]$/
-        parms[$1] ||= {}
-        parms[$1] = normalize_params(parms[$1], $2, val)
-      when /(.+)\[\]$/
-        (parms[$1] ||= []) << val
+    # 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
-        parms[key] = val if val
+        "#{prefix}=#{escape(value)}"
       end
-      parms
     end
     
-    
-    # parses a query string or the payload of a POST
-    # request into the params hash. So for example:
-    # /foo?bar=nik&post[title]=heya&post[body]=whatever
-    # parses into:
-    # {:bar => 'nik', :post => {:title => 'heya', :body => 'whatever'}}
-    def query_parse(qs, d = '&;')
-      m = proc {|_,o,n|o.update(n,&m)rescue([*o]<<n)}
-      (qs||'').split(/[#{d}] */n).inject(Hash[]) { |h,p| 
-              k, v=unescape(p).split('=',2)
-              h.update(k.split(/[\]\[]+/).reverse.
-                inject(v) { |x,i| Hash[i,x] },&m)
-          }
+    # +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
@@ -231,10 +246,8 @@ module Merb
     # stream_file( { :filename => file_name, 
     #                :type => content_type,
     #                :content_length => content_length }) do
-    #   response.send_status(opts[:content_length])
-    #   response.send_header
     #   AWS::S3::S3Object.stream(user.folder_name + "-" + user_file.unique_id, bucket_name) do |chunk|
-    #       @response.write chunk
+    #       response.write chunk
     #   end
     # end
     def stream_file(opts={}, &stream)
@@ -247,6 +260,8 @@ module Merb
         'Content-Transfer-Encoding' => 'binary',
         'CONTENT-LENGTH'            => opts[:content_length]
       )
+      response.send_status(opts[:content_length])
+      response.send_header
       stream
     end
     
@@ -261,8 +276,12 @@ module Merb
   
     # Sets a cookie to be included in the response.
     def set_cookie(name, value, expires)
-      (headers['Set-Cookie'] ||='') << 
-        (Merb::Const::SET_COOKIE % [name.to_s, escape(value.to_s), expires.rfc2822])
+      (headers['Set-Cookie'] ||='') << (Merb::Const::SET_COOKIE % [
+        name.to_s, 
+        escape(value.to_s), 
+        # Cookie expiration time must be GMT. See RFC 2109
+        expires.gmtime.strftime(Merb::Const::COOKIE_EXPIRATION_FORMAT)
+      ])
     end
     
     # Marks a cookie as deleted. The cookie is given an expires stamp in