narf 0.5.1

data/lib/web/mime.rb

@@ -0,0 +1,82 @@
+module Web
+  # == Purpose
+  # This class returns mime types.  It parses an apache-style mime.types file
+  # located in site_lib/web/resources/mime.types for it's database.
+  # 
+  # This class can be independantly of the rest of NARF:
+  #
+  #     require 'web/mime.rb'
+  #     Web::Mime::get_mime_type( 'filename.txt' )
+  #
+  class Mime
+    DEFAULT_MIMETYPE  = "text/html"
+    @@readers = []
+    def Mime.readers
+      @@readers
+    end
+    
+    class ApacheUnixReader #:nodoc:
+      MIME_FILENAME = "mime.types"
+      COMMENTED_PATTERN = /(^\s*#)|(^\s*$)/
+      VALUE_PATTERN     = /\.*(\S+)\s*=\s*(\S+)/
+      
+      def self.mime_file
+        File.join( File.dirname( __FILE__ ),
+                   "resources",
+                   MIME_FILENAME )
+      end
+      
+      def self.applies?
+        File.exists? mime_file
+      end
+      
+      def mime_types
+        mime_array = File.open( self.class.mime_file, "r" ) { |f|
+          f.read.to_a
+        }
+        mime_array.uniq!
+        mime_array.delete_if { |line|
+          line =~ COMMENTED_PATTERN
+        }
+        mime_hash = {}
+        mime_hash.default = DEFAULT_MIMETYPE
+        mime_array.each { |line|
+          pieces = line.split( /\s+/ )
+          mime_type = pieces.shift
+          pieces.each { |extension|
+            mime_hash[extension] = mime_type
+          }
+        }
+        mime_hash
+      end
+      
+      Mime.readers.push self
+    end
+    
+    @@mime_types = nil
+    def Mime.clear
+      @@mime_types = nil
+    end
+
+    def Mime.mime_types
+      unless(@@mime_types)
+        Mime.readers.each{ |klass|
+	  if klass.applies?
+            @@mime_types = klass.new.mime_types
+            break
+          end
+        }
+      end
+      @@mime_types
+    end
+    
+    def Mime.get_mime_type( filename )
+      mime_types[filename.split(".").last].to_s
+    end
+  end
+
+  def Web.get_mime_type( filename )
+    Mime.get_mime_type( filename )
+  end
+
+end 

data/lib/web/parser.rb

@@ -0,0 +1,266 @@
+require 'tempfile'
+
+module Web
+  # == Purpose
+  #
+  # this hash is has case insensitive keys.  Might be somewhat
+  # incomplete
+  class CaseInsensitiveHash < Hash #:nodoc:
+    def [](key)
+      super( key.to_s.downcase )
+    end
+    
+    def []= (key, value)
+      super( key.to_s.downcase, value )
+    end
+
+    def has_key? (key)
+      super( key.to_s.downcase )
+    end
+  end
+
+  # == Purpose
+  #
+  # This module contains methods to parse web requests.
+  # Parser counts on the attributes of a cgd: options, input, env
+  module Parser
+
+    # This method counts on the attributes of a cgd: options, input, env
+    # It will set @cookies and @multiple_params
+    def parse_request
+      @cookies  ||= normalize(options[:cookies] ||
+                              parse_cookie( env['http_cookie'] ||
+                                            env['cookie'] ) )
+
+      @multiple_params ||= normalize( options[:params] ||
+                  parse_params )
+
+    end
+
+    # returns a hash with downcased keys of the env_in variable
+    def downcase_env( env_in )
+      env = CaseInsensitiveHash.new
+      env_in.each{ |k, v|
+        env[k.downcase] = v
+      }
+      env
+    end
+
+    # normalizes a params hash
+    def Parser.normalize( params )
+      params.each { |key, value|
+        unless value.kind_of? Array
+          params[key] = [value]
+        end
+      }
+      params.default = []
+      params
+    end
+
+    def normalize(params)
+      Parser.normalize(params)
+    end
+
+    # Parse a raw cookie string
+    def Parser.parse_cookie(raw_cookie)
+      cookies = Hash.new([])
+      return cookies unless raw_cookie
+      
+      raw_cookie.split(/; /).each do |pairs|
+        name, values = pairs.split('=',2)
+        name = Web::unescape(name)
+        values ||= ""
+        values = values.split('&').collect{|v| Web::unescape(v) }
+        if cookies.has_key?(name)
+          cookies[name].push(*values)
+        else
+          cookies[name] = values
+        end
+      end
+      
+      cookies
+    end
+    
+    def parse_cookie(raw_cookie)
+      Parser.parse_cookie(raw_cookie)
+    end
+
+    # parse and return multiple_params
+    def parse_params
+      if (multipart?)
+        parse_multipart
+      else
+        parse_query_string( query_string )
+      end
+    end
+    
+    def query_string #:nodoc:
+      case env["request_method"]
+      when "GET", "HEAD"
+        if (defined? MOD_RUBY) # <= this check is untested.
+          #    search the test files for
+          #    test_parse_get_with_mod_ruby
+          #    for an explanation
+          mod_ruby_query_string
+        else
+          env["query_string"]
+        end
+      when "POST"
+        input.binmode
+        input.read(Integer(env['content_length']))
+      end
+    end
+    
+    # this method solely exists b/c of difficulties setting MOD_RUBY dynamically.
+    # so this method exists so I can test the effect separately
+    # from the (currently untestable) cause
+    def Parser.mod_ruby_query_string     #:nodoc:
+      Apache::request.args
+    end
+    
+    def mod_ruby_query_string #:nodoc:
+      Parser.mod_ruby_query_string
+    end
+    
+    # Parse a query_string into parameters
+    def Parser.parse_query_string(query)
+      query ||= ""
+      params = Hash.new([])
+      
+      query.split(/[&;]/n).each do |pairs|
+        key, value = pairs.split('=',2).collect{|v| Web::unescape(v) }
+        if params.has_key?(key)
+          params[key].push(value)
+        else
+          params[key] = [value]
+        end
+      end
+      
+      params
+    end
+
+    def parse_query_string(query)
+      Parser.parse_query_string(query)
+    end
+    
+    # note this returns the un-arrayified version of the array
+    def parse_query_string_typed(query) #:nodoc: :notest:
+      params = parse_query_string query
+      params2 = {}
+      params.collect do |k,v|
+        if ! (k =~ /type/)
+          if (atype = params["#{k}#type"][0]) 
+            params2[k] = Module.const_get(atype.intern).unencode(v[0])
+          else
+            params2[k] = v[0]
+          end
+        end
+      end
+      params2
+    end
+    
+    def multipart?
+      ("POST" == env['request_method']) &&
+            (/multipart\/form-data/.match(env['content_type']))
+    end
+    
+    # parse multipart/form-data
+    def parse_multipart
+      %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n.match(env['content_type'])
+      boundary = $1.dup
+      
+      read_multipart(boundary, Integer(env['content_length']))
+    end
+    
+    EOL="\r\n"
+    
+    def read_multipart(boundary, content_length)  #:nodoc:
+      params = Hash.new([])
+      boundary = "--" + boundary
+      buf = ""
+      bufsize = 10 * 1024
+      
+      # start multipart/form-data
+      input.binmode
+      boundary_size = boundary.size + EOL.size
+      content_length -= boundary_size
+      status = input.read(boundary_size)
+      if nil == status
+        raise EOFError, "no content body"
+      end
+      
+      until -1 == content_length
+        head = nil
+        body = Tempfile.new("Web")
+        body.binmode
+        
+        until head and /#{boundary}(?:#{EOL}|--)/n.match(buf)
+          
+          if head
+            trim_size = (EOL + boundary + EOL).size
+            if trim_size < buf.size
+              body.print buf[0 ... (buf.size - trim_size)]
+              buf[0 ... (buf.size - trim_size)] = ""
+            end
+          elsif /#{EOL}#{EOL}/n.match(buf)
+            buf = buf.sub(/\A((?:.|\n)*?#{EOL})#{EOL}/n) do
+              head = $1.dup
+              ""
+            end
+            next
+          end
+          
+          c = if bufsize < content_length
+                input.read(bufsize) or ''
+              else
+                input.read(content_length) or ''
+              end
+          buf.concat c
+          content_length -= c.size
+          
+        end
+        
+        
+        /Content-Disposition:.* filename="?([^\";]*)"?/ni.match(head)
+        filename = ($1 or "").dup
+        if /Mac/ni.match(env['http_user_agent']) and
+            /Mozilla/ni.match(env['http_user_agent']) and
+            (not /MSIE/ni.match(env['http_user_agent']))
+          filename = Web::unescape(filename)
+        end
+        
+        /Content-Type: (.*)/ni.match(head)
+        content_type = ($1 or "").strip
+        
+        buf = buf.sub(/\A((?:.|\n)*?)(?:#{EOL})?#{boundary}(#{EOL}|--)/n) do
+          body.print $1
+          if "--" == $2
+            content_length = -1
+          end
+          ""
+        end
+        
+        body.rewind
+        
+        if (content_type.empty?)
+          upload = body.read
+        else
+          upload = Web::Upload.new( body, content_type, filename )
+        end
+
+        /Content-Disposition:.* name="?([^\";]*)"?/ni.match(head)
+        name = $1.dup
+        
+        if params.has_key?(name)
+          params[name].push(upload)
+        else
+          params[name] = [upload]
+        end
+        
+      end
+      
+      params
+    end # read_multipart
+    
+  end
+end

data/lib/web/parser.rb~

@@ -0,0 +1,266 @@
+require 'tempfile'
+
+module Web
+  # == Purpose
+  #
+  # this hash is has case insensitive keys.  Might be somewhat
+  # incomplete
+  class CaseInsensitiveHash < Hash
+    def [](key)
+      super( key.to_s.downcase )
+    end
+    
+    def []= (key, value)
+      super( key.to_s.downcase, value )
+    end
+
+    def has_key? (key)
+      super( key.to_s.downcase )
+    end
+  end
+
+  # == Purpose
+  #
+  # This module contains methods to parse web requests.
+  # Parser counts on the attributes of a cgd: options, input, env
+  module Parser
+
+    # This method counts on the attributes of a cgd: options, input, env
+    # It will set @cookies and @multiple_params
+    def parse_request
+      @cookies  ||= normalize(options[:cookies] ||
+                              parse_cookie( env['http_cookie'] ||
+                                            env['cookie'] ) )
+
+      @multiple_params ||= normalize( options[:params] ||
+                  parse_params )
+
+    end
+
+    # returns a hash with downcased keys of the env_in variable
+    def downcase_env( env_in )
+      env = CaseInsensitiveHash.new
+      env_in.each{ |k, v|
+        env[k.downcase] = v
+      }
+      env
+    end
+
+    # normalizes a params hash
+    def Parser.normalize( params )
+      params.each { |key, value|
+        unless value.kind_of? Array
+          params[key] = [value]
+        end
+      }
+      params.default = []
+      params
+    end
+
+    def normalize(params)
+      Parser.normalize(params)
+    end
+
+    # Parse a raw cookie string
+    def Parser.parse_cookie(raw_cookie)
+      cookies = Hash.new([])
+      return cookies unless raw_cookie
+      
+      raw_cookie.split(/; /).each do |pairs|
+        name, values = pairs.split('=',2)
+        name = Web::unescape(name)
+        values ||= ""
+        values = values.split('&').collect{|v| Web::unescape(v) }
+        if cookies.has_key?(name)
+          cookies[name].push(*values)
+        else
+          cookies[name] = values
+        end
+      end
+      
+      cookies
+    end
+    
+    def parse_cookie(raw_cookie)
+      Parser.parse_cookie(raw_cookie)
+    end
+
+    # parse and return multiple_params
+    def parse_params
+      if (multipart?)
+        parse_multipart
+      else
+        parse_query_string( query_string )
+      end
+    end
+    
+    def query_string #:nodoc:
+      case env["request_method"]
+      when "GET", "HEAD"
+        if (defined? MOD_RUBY) # <= this check is untested.
+          #    search the test files for
+          #    test_parse_get_with_mod_ruby
+          #    for an explanation
+          mod_ruby_query_string
+        else
+          env["query_string"]
+        end
+      when "POST"
+        input.binmode
+        input.read(Integer(env['content_length']))
+      end
+    end
+    
+    # this method solely exists b/c of difficulties setting MOD_RUBY dynamically.
+    # so this method exists so I can test the effect separately
+    # from the (currently untestable) cause
+    def Parser.mod_ruby_query_string     #:nodoc:
+      Apache::request.args
+    end
+    
+    def mod_ruby_query_string #:nodoc:
+      Parser.mod_ruby_query_string
+    end
+    
+    # Parse a query_string into parameters
+    def Parser.parse_query_string(query)
+      query ||= ""
+      params = Hash.new([])
+      
+      query.split(/[&;]/n).each do |pairs|
+        key, value = pairs.split('=',2).collect{|v| Web::unescape(v) }
+        if params.has_key?(key)
+          params[key].push(value)
+        else
+          params[key] = [value]
+        end
+      end
+      
+      params
+    end
+
+    def parse_query_string(query)
+      Parser.parse_query_string(query)
+    end
+    
+    # note this returns the un-arrayified version of the array
+    def parse_query_string_typed(query) #:nodoc: :notest:
+      params = parse_query_string query
+      params2 = {}
+      params.collect do |k,v|
+        if ! (k =~ /type/)
+          if (atype = params["#{k}#type"][0]) 
+            params2[k] = Module.const_get(atype.intern).unencode(v[0])
+          else
+            params2[k] = v[0]
+          end
+        end
+      end
+      params2
+    end
+    
+    def multipart?
+      ("POST" == env['request_method']) &&
+            (/multipart\/form-data/.match(env['content_type']))
+    end
+    
+    # parse multipart/form-data
+    def parse_multipart
+      %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n.match(env['content_type'])
+      boundary = $1.dup
+      
+      read_multipart(boundary, Integer(env['content_length']))
+    end
+    
+    EOL="\r\n"
+    
+    def read_multipart(boundary, content_length)  #:nodoc:
+      params = Hash.new([])
+      boundary = "--" + boundary
+      buf = ""
+      bufsize = 10 * 1024
+      
+      # start multipart/form-data
+      input.binmode
+      boundary_size = boundary.size + EOL.size
+      content_length -= boundary_size
+      status = input.read(boundary_size)
+      if nil == status
+        raise EOFError, "no content body"
+      end
+      
+      until -1 == content_length
+        head = nil
+        body = Tempfile.new("Web")
+        body.binmode
+        
+        until head and /#{boundary}(?:#{EOL}|--)/n.match(buf)
+          
+          if head
+            trim_size = (EOL + boundary + EOL).size
+            if trim_size < buf.size
+              body.print buf[0 ... (buf.size - trim_size)]
+              buf[0 ... (buf.size - trim_size)] = ""
+            end
+          elsif /#{EOL}#{EOL}/n.match(buf)
+            buf = buf.sub(/\A((?:.|\n)*?#{EOL})#{EOL}/n) do
+              head = $1.dup
+              ""
+            end
+            next
+          end
+          
+          c = if bufsize < content_length
+                input.read(bufsize) or ''
+              else
+                input.read(content_length) or ''
+              end
+          buf.concat c
+          content_length -= c.size
+          
+        end
+        
+        
+        /Content-Disposition:.* filename="?([^\";]*)"?/ni.match(head)
+        filename = ($1 or "").dup
+        if /Mac/ni.match(env['http_user_agent']) and
+            /Mozilla/ni.match(env['http_user_agent']) and
+            (not /MSIE/ni.match(env['http_user_agent']))
+          filename = Web::unescape(filename)
+        end
+        
+        /Content-Type: (.*)/ni.match(head)
+        content_type = ($1 or "").strip
+        
+        buf = buf.sub(/\A((?:.|\n)*?)(?:#{EOL})?#{boundary}(#{EOL}|--)/n) do
+          body.print $1
+          if "--" == $2
+            content_length = -1
+          end
+          ""
+        end
+        
+        body.rewind
+        
+        if (content_type.empty?)
+          upload = body.read
+        else
+          upload = Web::Upload.new( body, content_type, filename )
+        end
+
+        /Content-Disposition:.* name="?([^\";]*)"?/ni.match(head)
+        name = $1.dup
+        
+        if params.has_key?(name)
+          params[name].push(upload)
+        else
+          params[name] = [upload]
+        end
+        
+      end
+      
+      params
+    end # read_multipart
+    
+  end
+end