merb 0.5.3 → 0.9.2

data/lib/merb/mixins/web_controller.rb

@@ -1,36 +0,0 @@
-# Used by secondary actions (a PartsController or the view)
-# to provide the standard objects associated with each request.
-
-module Merb
-  module WebControllerMixin #:nodoc:
-    
-    def request
-       @web_controller.request  
-    end
-            
-    def params
-      @web_controller.params
-    end  
-    
-    def cookies
-      @web_controller.cookies
-    end  
-
-    def headers
-      @web_controller.headers
-    end
-    
-    def session
-      @web_controller.session
-    end
-
-    def response
-      @web_controller.response
-    end    
-    
-    def route
-      request.route
-    end
-     
-  end
-end

data/lib/merb/mongrel_handler.rb

@@ -1,168 +0,0 @@
-class Mongrel::HttpResponse
-  NO_CLOSE_STATUS_FORMAT = "HTTP/1.1 %d %s\r\n".freeze
-  def send_status_no_connection_close(content_length=@body.length)
-    unless @status_sent
-      @header['Content-Length'] = content_length unless @status == 304
-      write(NO_CLOSE_STATUS_FORMAT % [@status, Mongrel::HTTP_STATUS_CODES[@status]])
-      @status_sent = true
-    end
-  end
-end  
-
-class MerbHandler < Mongrel::HttpHandler
-  @@file_only_methods    = ["GET","HEAD"]
-  @@path_prefix          = nil
-  @@path_prefix_original = nil
-  
-  class << self
-    # Use :path_prefix in merb.yml to set this
-    def path_prefix() @@path_prefix_original end
-    def path_prefix=(prefix)
-      @@path_prefix_original = prefix
-      @@path_prefix          = (prefix.is_a?(String) ? /^#{prefix.escape_regexp}/ : prefix)
-    end
-  end
-  
-  # Take the name of a directory and use that as the doc root or public
-  # directory of your site. This is set to the root of your merb app + '/public'
-  # by default.
-  def initialize(dir, mongrel_x_sendfile=true, opts = {})
-    @files = Mongrel::DirHandler.new(dir,false)
-    @mongrel_x_sendfile = mongrel_x_sendfile
-  end
-  
-  # process incoming http requests and do a number of things
-  # 1. Check for rails style cached pages. add .html to the url and see if
-  # there is a static file in public that matches. serve that file directly
-  # without invoking Merb and be done with it.
-  # 2. Serve static asset and html files directly from public/ if they exist.
-  # 3. If none of the above apply, we take apart the request url and feed it
-  # into Merb::RouteMatcher to let it decide which controller and method will
-  # serve the request.
-  # 4. After the controller has done its thing, we check for the X-SENDFILE
-  # header. if you set this header to the path of a file in your controller
-  # then mongrel will serve the file directly and your controller can go on
-  # processing other requests.
-  def process(request, response) 
-    return if response.socket.closed?
-       
-    start      = Time.now
-    benchmarks = {}
-    
-    Merb.logger.info("\nRequest: REQUEST_URI: #{
-      request.params[Mongrel::Const::REQUEST_URI]}  (#{Time.now.strftime("%Y-%m-%d %H:%M:%S")})")
-    
-    # Truncate the request URI if there's a path prefix so that an app can be
-    # hosted inside a subdirectory, for example.
-    if @@path_prefix
-      if request.params[Mongrel::Const::PATH_INFO] =~ @@path_prefix
-        Merb.logger.info("Path prefix #{@@path_prefix.inspect} removed from PATH_INFO and REQUEST_URI.")
-        request.params[Mongrel::Const::PATH_INFO].sub!(@@path_prefix, '')
-        request.params[Mongrel::Const::REQUEST_URI].sub!(@@path_prefix, '')
-        path_info = request.params[Mongrel::Const::PATH_INFO]
-      else
-        raise "Path prefix is set to '#{@@path_prefix.inspect}', but is not in the REQUEST_URI. "
-      end
-    else
-      path_info = request.params[Mongrel::Const::PATH_INFO]
-    end
-    
-    # Rails style page caching. Check the public dir first for .html pages and
-    # serve directly. Otherwise fall back to Merb routing and request
-    # dispatching.
-    page_cached = path_info + ".html"
-    get_or_head = @@file_only_methods.include? request.params[Mongrel::Const::REQUEST_METHOD]
-
-    if get_or_head && @files.can_serve(path_info)
-      # File exists as-is so serve it up
-      Merb.logger.info("Serving static file: #{path_info}")
-      @files.process(request,response)
-    elsif get_or_head && @files.can_serve(page_cached)
-      # Possible cached page, serve it up
-      Merb.logger.info("Serving static file: #{page_cached}")
-      request.params[Mongrel::Const::PATH_INFO] = page_cached
-      @files.process(request,response)
-    else
-      # Let Merb:Dispatcher find the route and call the filter chain and action
-      controller, action      = Merb::Dispatcher.handle(request, response)  
-      benchmarks.merge!(controller._benchmarks)
-      benchmarks[:controller] = controller.class.to_s
-      benchmarks[:action]     = action
-
-      Merb.logger.info("Routing to controller: #{controller.class} action: #{action}\nRoute Recognition & Parsing HTTP Input took: #{benchmarks[:setup_time]} seconds")
-      
-      sendfile, clength = nil
-      response.status   = controller.status
-      # Check for the X-SENDFILE header from your Merb::Controller and serve
-      # the file directly instead of buffering.
-      controller.headers.each do |k, v|
-        if k =~ /^X-SENDFILE$/i
-          sendfile = v
-        elsif k =~ /^CONTENT-LENGTH$/i
-          clength = v.to_i
-        else
-          [*v].each do |vi|
-            response.header[k] = vi
-          end
-        end
-      end
-      
-      if sendfile
-        if @mongrel_x_sendfile
-          # we want to emulate X-Sendfile header internally in mongrel
-          benchmarks[:sendfile_time] = Time.now - start        
-          Merb.logger.info("X-SENDFILE: #{sendfile}\nComplete Request took: #{
-            benchmarks[:sendfile_time]} seconds")
-          file_status     = File.stat(sendfile)
-          response.status = 200
-          # Set the last modified times as well and etag for all files
-          response.header[Mongrel::Const::LAST_MODIFIED] = file_status.mtime.httpdate
-          # Calculated the same as apache, not sure how well the works on win32
-          response.header[Mongrel::Const::ETAG] = Mongrel::Const::ETAG_FORMAT % [file_status.mtime.to_i, file_status.size, file_status.ino]
-          # Send a status with out content length
-          response.send_status(file_status.size)
-          response.send_header
-          response.send_file(sendfile)  
-        else
-          # we want to pass thru the X-Sendfile header so apache or whatever 
-          # front server can handle it
-          response.header['X-Sendfile'] = sendfile
-          response.header['Content-length'] = clength || File.size(sendfile)
-          response.finished
-        end    
-      elsif controller.body.respond_to? :read
-        response.send_status(clength)
-        response.send_header
-        while chunk = controller.body.read(16384)
-          response.write(chunk)
-        end
-        if controller.body.respond_to? :close
-          controller.body.close
-        end
-      elsif Proc === controller.body
-        controller.body.call
-      else
-        # Render response from successful controller
-        body = (controller.body.to_s rescue '') 
-        response.send_status(body.length)
-        response.send_header
-        response.write(body)
-      end
-
-      total_request_time = Time.now - start
-      benchmarks[:total_request_time] = total_request_time
-        
-      Merb.logger.info("Request Times: #{benchmarks.inspect}\nResponse status: #{response.status}\nComplete Request took: #{total_request_time} seconds, #{1.0/total_request_time} Requests/Second\n\n")
-    end
-  rescue Object => e
-    # if an exception is raised here then something is 
-    # wrong with the dispatcher code so we shouldn't pass the
-    # exception back in or we might end up in a loop
-    response.send_status(500)
-    response.send_header
-    response.write("500 Internal Server Error")
-    Merb.logger.error(Merb.exception(e))
-  ensure
-    Merb.logger.flush
-  end
-end

data/lib/merb/part_controller.rb

@@ -1,29 +0,0 @@
-module Merb
-  class PartController < AbstractController
-    self._template_root = File.expand_path(self._template_root / "../parts/views")
-    include Merb::WebControllerMixin
-    
-    def initialize(web_controller)
-      @web_controller = web_controller
-      super
-    end
-
-    def dispatch(action=:to_s)
-      old_action = params[:action]
-      params[:action] = action
-      super(action)
-      params[:action] = old_action
-      @_body
-    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)
-       controller = opts[:controller] || @web_controller.params[:controller]
-       raise "No Controller Specified for url()" unless controller
-       controller
-    end
-  end
-end    

data/lib/merb/plugins.rb

@@ -1,16 +0,0 @@
-module Merb
-  module Plugins
-    def self.config
-      @config ||= File.exists?(Merb.root / "config" / "plugins.yml") ? YAML.load(File.read(Merb.root / "config" / "plugins.yml")) || {} : {}
-    end
-    
-    @rakefiles = []
-    def self.rakefiles
-      @rakefiles
-    end
-    
-    def self.add_rakefiles(*rakefiles)
-      @rakefiles += rakefiles
-    end
-  end
-end

data/lib/merb/rack_adapter.rb

@@ -1,37 +0,0 @@
-module Merb
-  module Rack
-    
-    class RequestWrapper
-      def initialize(env)
-        @env = env
-      end
-      
-      def params
-        @env
-      end
-      
-      def body
-        @env['rack.input']
-      end
-    end
-      
-    class Adapter
-      def call(env)
-        env["PATH_INFO"] ||= ""
-        env["SCRIPT_NAME"] ||= ""
-        if env["REQUEST_URI"] =~ %r{(https?://)[^/](.*)}
-          env["REQUEST_URI"] = $2
-        end  
-        request = RequestWrapper.new(env)
-        response = StringIO.new
-        begin
-          controller, action = ::Merb::Dispatcher.handle(request, response)
-        rescue Object => e
-          return [500, {"Content-Type"=>"text/html"}, "Internal Server Error"]
-        end
-        
-        [controller.status, controller.headers, controller.body]
-      end
-    end
-  end
-end

data/lib/merb/request.rb

@@ -1,465 +0,0 @@
-module Merb
-  class Request
-    attr_accessor :env, :session
-    
-    # by setting these to false, auto-parsing is disabled; this way you can do your own parsing instead
-    cattr_accessor :parse_multipart_params, :parse_json_params, :parse_xml_params
-    self.parse_multipart_params = true
-    self.parse_json_params = true
-    self.parse_xml_params = true
-    
-    def initialize(http_request)
-      @env = http_request.params
-      @body = http_request.body
-    end
-    
-    METHODS = %w{get post put delete head}
-    
-    def method
-      @method ||= begin
-        request_method = @env['REQUEST_METHOD'].downcase.to_sym
-        case request_method
-        when :get, :head, :put, :delete
-          request_method
-        when :post
-          if self.class.parse_multipart_params
-            m = body_and_query_params.merge(multipart_params)['_method']
-          else  
-            m = body_and_query_params['_method']
-          end  
-          m.downcase! if m
-          METHODS.include?(m) ? m.to_sym : :post
-        else
-          raise "Unknown REQUEST_METHOD: #{@env['REQUEST_METHOD']}"
-        end
-      end
-    end
-    
-    # create predicate methods for querying the REQUEST_METHOD
-    # get? post? head? put? etc
-    METHODS.each do |m|
-      define_method("#{m}?") { method == m.to_sym }
-    end
-    
-    private
-    
-    # FIXME: symbolize_keys on params is a potential problem. symbols are 
-    # not garbage collected so a malicious user could send many large query
-    # keys to Merb forcing it to eat up memeory.
-    
-    # A hash of parameters passed from the URL like ?blah=hello
-    def query_params
-      @query_params ||= self.class.query_parse(query_string || '')
-    end
-    
-    # A hash of parameters passed in the body of the request.
-    #
-    # Ajax calls from prototype.js and other libraries 
-    # pass content this way.
-    def body_params
-      @body_params ||= begin
-        if content_type && content_type.match(Merb::Const::FORM_URL_ENCODED_REGEXP) # or content_type.nil?
-          self.class.query_parse(raw_post)
-        end
-      end
-    end
-    
-    def body_and_query_params
-      # ^-- FIXME a better name for this method
-      @body_and_query_params ||= begin
-        h = query_params
-        h.merge!(body_params) if body_params
-        h.to_mash
-      end
-    end
-    
-    def multipart_params
-      @multipart_params ||= 
-        begin
-          if Merb::Const::MULTIPART_REGEXP =~ content_type
-            if  @body.size <= 0
-              {}
-            else  
-              self.class.parse_multipart(@body, $1, content_length)
-            end
-          else
-            {}
-          end
-        rescue ControllerExceptions::MultiPartParseError => e
-          @multipart_params = {}
-          raise e
-        end
-    end
-    
-    def json_params
-      @json_params ||= begin
-        if Merb::Const::JSON_MIME_TYPE_REGEXP.match(content_type)
-          JSON.parse(raw_post)
-        end
-      end
-    end
-    
-    def xml_params
-      @xml_params ||= begin
-        if Merb::Const::XML_MIME_TYPE_REGEXP.match(content_type)
-          Hash.from_xml(raw_post) rescue Mash.new
-        end
-      end
-    end
-    
-    public
-    
-    def params
-      @params ||= begin
-        h = body_and_query_params.merge(route_params)      
-        h.merge!(multipart_params) if self.class.parse_multipart_params && multipart_params
-        h.merge!(json_params) if self.class.parse_json_params && json_params
-        h.merge!(xml_params) if self.class.parse_xml_params && xml_params
-        h
-      end
-    end
-    
-    def cookies
-      @cookies ||= self.class.query_parse(@env[Merb::Const::HTTP_COOKIE], ';,')
-    end
-    
-    def route
-      @route ||= Merb::Router.routes[route_index]
-    end
-    
-    # returns two objects, route_index and route_params
-    def route_match
-      @route_match ||= Merb::Router.match(self, body_and_query_params)
-    end
-    private :route_match
-    
-    def route_index
-      route_match.first
-    end
-    
-    def route_params
-      route_match.last
-    end
-    
-    def controller_name
-      if route_params[:namespace]
-        route_params[:namespace] + '/' + route_params[:controller]
-      else
-        route_params[:controller]
-      end
-    end
-    
-    def controller_class
-      begin
-        cnt = controller_name.to_const_string
-      rescue ::String::InvalidPathConversion
-        raise ControllerExceptions::NotFound
-      end
-      if !Controller._subclasses.include?(cnt)
-        raise ControllerExceptions::NotFound, "Controller '#{cnt}' not found"
-      end
-      
-      begin
-        if cnt == "Application"
-          raise ControllerExceptions::NotFound, "The 'Application' controller has no public actions" 
-        end
-        return Object.full_const_get(cnt)
-      rescue NameError
-        raise ControllerExceptions::NotFound
-      end
-    end
-    
-    def action
-      route_params[:action]
-    end
-    
-    def raw_post
-      @body.rewind
-      res = @body.read
-      @body.rewind
-      res
-    end
-    
-    # Returns true if the request is an Ajax request.
-    #
-    # Also aliased as the more memorable ajax? and xhr?.
-    def xml_http_request?
-      not /XMLHttpRequest/i.match(@env['HTTP_X_REQUESTED_WITH']).nil?
-    end
-    alias xhr? :xml_http_request?
-    alias ajax? :xml_http_request?
-    
-    # returns the remote IP address if it can find it.
-    def remote_ip
-      return @env['HTTP_CLIENT_IP'] if @env.include?('HTTP_CLIENT_IP')
-    
-      if @env.include?(Merb::Const::HTTP_X_FORWARDED_FOR) then
-        remote_ips = @env[Merb::Const::HTTP_X_FORWARDED_FOR].split(',').reject do |ip|
-          ip =~ /^unknown$|^(127|10|172\.16|192\.168)\./i
-        end
-    
-        return remote_ips.first.strip unless remote_ips.empty?
-      end
-    
-      return @env[Merb::Const::REMOTE_ADDR]
-    end
-    
-    # returns either 'https://' or 'http://' depending on
-    # the HTTPS header
-    def protocol
-      ssl? ? 'https://' : 'http://'
-    end
-    
-    # returns true if the request is an SSL request
-    def ssl?
-      @env['HTTPS'] == 'on' || @env['HTTP_X_FORWARDED_PROTO'] == 'https'
-    end
-    
-    # returns the request HTTP_REFERER.
-    def referer
-      @env['HTTP_REFERER']
-    end
-    
-    # returns he request uri.
-    def uri
-      @env['REQUEST_URI']
-    end
-    
-    def user_agent
-      @env['HTTP_USER_AGENT']
-    end
-
-    def server_name
-      @env['SERVER_NAME']
-    end
-
-    def accept_encoding
-      @env['HTTP_ACCEPT_ENCODING']
-    end
-
-    def script_name
-      @env['SCRIPT_NAME']
-    end
-
-    def cache_control
-      @env['HTTP_CACHE_CONTROL']
-    end
-
-    def accept_language
-      @env['HTTP_ACCEPT_LANGUAGE']
-    end
-
-    def host
-      @env['HTTP_HOST']
-    end
-
-    def server_software
-      @env['SERVER_SOFTWARE']
-    end
-
-    def keep_alive
-      @env['HTTP_KEEP_ALIVE']
-    end
-
-    def accept_charset
-      @env['HTTP_ACCEPT_CHARSET']
-    end
-
-    def version
-      @env['HTTP_VERSION']
-    end
-
-    def gateway
-      @env['GATEWAY_INTERFACE']
-    end
-
-    def accept
-      @env['HTTP_ACCEPT'].blank? ? "*/*" : @env['HTTP_ACCEPT']
-    end
-
-    def connection
-      @env['HTTP_CONNECTION']
-    end
-
-    def query_string
-      @env['QUERY_STRING']  
-    end
-    
-    def content_type
-      @env['CONTENT_TYPE']
-    end
-    
-    def content_length
-      @content_length ||= @env[Merb::Const::CONTENT_LENGTH].to_i
-    end
-    
-    # Returns the uri without the query string. Strips trailing '/' and reduces
-    # duplicate '/' to a single '/'
-    def path
-      path = (uri ? uri.split('?').first : '').sub(/\/+/, '/')
-      path = path[0..-2] if (path[-1] == ?/) && path.size > 1
-      path
-    end
-    
-    # returns the PATH_INFO
-    def path_info
-      @path_info ||= Mongrel::HttpRequest.unescape(@env['PATH_INFO'])
-    end
-    
-    # returns the port the server is running on
-    def port
-      @env['SERVER_PORT'].to_i
-    end
-    
-    # returns the full hostname including port
-    def host
-      @env['HTTP_X_FORWARDED_HOST'] || @env['HTTP_HOST'] 
-    end
-    
-    # returns an array of all the subdomain parts of the host.
-    def subdomains(tld_length = 1)
-      parts = host.split('.')
-      parts[0..-(tld_length+2)]
-    end
-    
-    # returns the full domain name without the port number.
-    def domain(tld_length = 1)
-      host.split('.').last(1 + tld_length).join('.').sub(/:\d+$/,'')
-    end
-    
-    class << self
-      # Escapes +s+ for use in a URL.
-      #
-      # ==== Parameter
-      #
-      # +s+ - String to URL escape.
-      #
-      def escape(s)
-        s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
-          '%'+$1.unpack('H2'*$1.size).join('%').upcase
-        }.tr(' ', '+')
-      end
-
-      # Unescapes a string (i.e., reverse URL escaping).
-      #
-      # ==== Parameter 
-      #
-      # +s+ - String to unescape.
-      #
-      def unescape(s)
-        s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
-          [$1.delete('%')].pack('H*')
-        }
-      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 = '&;')
-        (qs||'').split(/[#{d}] */n).inject({}) { |h,p| 
-          normalize_params(h, *unescape(p).split('=',2))
-        }.to_mash
-      end
-    
-      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, content_length)
-        boundary = "--#{boundary}"
-        paramhsh = {}
-        buf = ""
-        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 ControllerExceptions::MultiPartParseError, "bad content body:\n'#{status}' should == '#{boundary + EOL}'"  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
-          
-            read_size = bufsize < content_length ? bufsize : content_length
-            if( read_size > 0 )
-              c = input.read(read_size)
-              raise ControllerExceptions::MultiPartParseError, "bad content body"  if c.nil? || c.empty?
-              buf << c
-              content_length -= c.size
-            end
-          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.path) 
-            }
-          else
-            data = body
-          end
-          paramhsh = normalize_params(paramhsh,name,data)
-          break  if buf.empty? || content_length == -1
-        }
-        paramhsh
-      end
-      
-      def normalize_params(parms, name, val=nil)
-        name =~ %r([\[\]]*([^\[\]]+)\]*)
-        key = $1 || ''
-        after = $' || ''
-        
-        if after == ""
-          parms[key] = val
-        elsif after == "[]"
-          (parms[key] ||= []) << val
-        else
-          parms[key] ||= {}
-          parms[key] = normalize_params(parms[key], after, val)
-        end
-        parms
-      end
-    end
-  end
-end    
-