mack 0.8.2 → 0.8.3

data/lib/gems/diff-lcs-1.1.2/lib/diff/lcs/string.rb

@@ -0,0 +1,19 @@
+#! /usr/env/bin ruby
+#--
+# Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
+#   adapted from:
+#     Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
+#     Smalltalk by Mario I. Wolczko <mario@wolczko.com>
+#   implements McIlroy-Hunt diff algorithm
+#
+# This program is free software. It may be redistributed and/or modified under
+# the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
+# Ruby licence.
+# 
+# $Id: string.rb,v 1.3 2004/08/08 20:33:09 austin Exp $
+#++
+# Includes Diff::LCS into String.
+
+class String
+  include Diff::LCS
+end

data/lib/gems/polyglot-0.2.3/lib/polyglot.rb

@@ -0,0 +1,62 @@
+$:.unshift File.dirname(__FILE__)
+
+module Polyglot
+  @registrations ||= {} # Guard against reloading
+  @loaded ||= {}
+
+  def self.register(extension, klass)
+    extension = [extension] unless Enumerable === extension
+    extension.each{|e|
+      @registrations[e] = klass
+    }
+  end
+
+  def self.find(file, *options, &block)
+    extensions = @registrations.keys*","
+    is_absolute = file[0] == File::SEPARATOR || file[0] == File::ALT_SEPARATOR || file =~ /\A[A-Z]:\\/i
+    (is_absolute ? [""] : $:).each{|lib|
+      base = is_absolute ? "" : lib+File::SEPARATOR
+      # In Windows, repeated SEPARATOR chars have a special meaning, avoid adding them
+      matches = Dir[base+file+".{"+extensions+"}"]
+      # Revisit: Should we do more do if more than one candidate found?
+      $stderr.puts "Polyglot: found more than one candidate for #{file}: #{matches*", "}" if matches.size > 1
+      if path = matches[0]
+        return [ path, @registrations[path.gsub(/.*\./,'')]]
+      end
+    }
+    return nil
+  end
+
+  def self.load(*a, &b)
+    return if @loaded[a[0]] # Check for $: changes or file time changes and reload?
+    begin
+      source_file, loader = Polyglot.find(*a, &b)
+      if (loader)
+        loader.load(source_file)
+        @loaded[a[0]] = true
+      else
+        msg = "Failed to load #{a[0]} using extensions #{(@registrations.keys+["rb"]).sort*", "}"
+        if defined?(MissingSourceFile)
+          raise MissingSourceFile.new(msg, a[0])
+        else
+          raise LoadError.new(msg)
+        end
+      end
+    end
+  end
+end
+
+module Kernel
+  alias polyglot_original_require require
+
+  def require(*a, &b)
+    polyglot_original_require(*a, &b)
+  rescue LoadError => load_error
+    begin
+      Polyglot.load(*a, &b)
+    rescue
+      # Raise the original exception, possibly a MissingSourceFile with a path
+      raise load_error
+    end
+  end
+end

data/lib/gems/polyglot-0.2.3/lib/polyglot/version.rb

@@ -0,0 +1,9 @@
+module Polyglot #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 3
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2007, 2008 Christian Neukirchen <purl.org/net/chneukirchen>
+# Copyright (C) 2007, 2008, 2009 Christian Neukirchen <purl.org/net/chneukirchen>
 #
 # Rack is freely distributable under the terms of an MIT-style license.
 # See COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -23,18 +23,23 @@ module Rack
 
   # Return the Rack release as a dotted string.
   def self.release
-    "0.4"
+    "0.9"
   end
 
   autoload :Builder, "rack/builder"
   autoload :Cascade, "rack/cascade"
   autoload :CommonLogger, "rack/commonlogger"
+  autoload :ConditionalGet, "rack/conditionalget"
+  autoload :ContentLength, "rack/content_length"
   autoload :File, "rack/file"
   autoload :Deflater, "rack/deflater"
   autoload :Directory, "rack/directory"
   autoload :ForwardRequest, "rack/recursive"
   autoload :Handler, "rack/handler"
+  autoload :Head, "rack/head"
   autoload :Lint, "rack/lint"
+  autoload :MethodOverride, "rack/methodoverride"
+  autoload :Mime, "rack/mime"
   autoload :Recursive, "rack/recursive"
   autoload :Reloader, "rack/reloader"
   autoload :ShowExceptions, "rack/showexceptions"

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack/adapter/camping.rb

@@ -15,7 +15,7 @@ module Rack
             h[k] = v.to_s
           end
         end
-        [controller.status, controller.headers, controller.body]
+        [controller.status, controller.headers, [controller.body.to_s]]
       end
     end
   end

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack/auth/openid.rb

@@ -343,7 +343,7 @@ module Rack
           session['authenticated'] = false
           req.env['rack.errors'].puts oid.message
 
-          goto = @options[:login_fail] if @option.key? :login_fail
+          goto = @options[:login_fail] if @options.key? :login_fail
           body << "Authentication unsuccessful.\n"
         when ::OpenID::Consumer::SUCCESS
           session.clear
@@ -367,7 +367,7 @@ module Rack
           session.clear
           session['authenticated'] = false
 
-          goto = @options[:login_fail] if @option.key? :login_fail
+          goto = @options[:login_fail] if @options.key? :login_fail
           body << "Authentication cancelled.\n"
         when ::OpenID::Consumer::SETUP_NEEDED
           session[:setup_needed] = true
@@ -402,7 +402,8 @@ module Rack
       def add_extension ext, *args
         if not ext.is_a? Module
           raise TypeError, "#{ext.inspect} is not a module"
-        elsif not (m = %w'Request Response NS_URI' - ext.constants).empty?
+        elsif !(m = %w'Request Response NS_URI' -
+                ext.constants.map{ |c| c.to_s }).empty?
           raise ArgumentError, "#{ext.inspect} missing #{m*', '}"
         end
 

data/lib/gems/{rack-0.4.0 → rack-0.9.1}/lib/rack/builder.rb

@@ -13,6 +13,13 @@ module Rack
   #    end
   #  }
   #
+  # Or
+  #
+  #  app = Rack::Builder.app do
+  #    use Rack::CommonLogger
+  #    lambda { |env| [200, {'Content-Type' => 'text/plain'}, 'OK'] }
+  #  end
+  #
   # +use+ adds a middleware to the stack, +run+ dispatches to an application.
   # You can use +map+ to construct a Rack::URLMap in a convenient way.
 
@@ -22,6 +29,10 @@ module Rack
       instance_eval(&block) if block_given?
     end
 
+    def self.app(&block)
+      self.new(&block).to_app
+    end
+
     def use(middleware, *args, &block)
       @ins << if block_given?
         lambda { |app| middleware.new(app, *args, &block) }
@@ -36,7 +47,7 @@ module Rack
 
     def map(path, &block)
       if @ins.last.kind_of? Hash
-        @ins.last[path] = Rack::Builder.new(&block).to_app
+        @ins.last[path] = self.class.new(&block).to_app
       else
         @ins << {}
         map(path, &block)

data/lib/gems/rack-0.9.1/lib/rack/conditionalget.rb

@@ -0,0 +1,43 @@
+module Rack
+
+  # Middleware that enables conditional GET using If-None-Match and
+  # If-Modified-Since. The application should set either or both of the
+  # Last-Modified or Etag response headers according to RFC 2616. When
+  # either of the conditions is met, the response body is set to be zero
+  # length and the response status is set to 304 Not Modified.
+  #
+  # Applications that defer response body generation until the body's each
+  # message is received will avoid response body generation completely when
+  # a conditional GET matches.
+  #
+  # Adapted from Michael Klishin's Merb implementation:
+  # http://github.com/wycats/merb-core/tree/master/lib/merb-core/rack/middleware/conditional_get.rb
+  class ConditionalGet
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      return @app.call(env) unless %w[GET HEAD].include?(env['REQUEST_METHOD'])
+
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+      if etag_matches?(env, headers) || modified_since?(env, headers)
+        status = 304
+        body = []
+      end
+      [status, headers, body]
+    end
+
+  private
+    def etag_matches?(env, headers)
+      etag = headers['Etag'] and etag == env['HTTP_IF_NONE_MATCH']
+    end
+
+    def modified_since?(env, headers)
+      last_modified = headers['Last-Modified'] and
+        last_modified == env['HTTP_IF_MODIFIED_SINCE']
+    end
+  end
+
+end

data/lib/gems/rack-0.9.1/lib/rack/content_length.rb

@@ -0,0 +1,25 @@
+module Rack
+  # Sets the Content-Length header on responses with fixed-length bodies.
+  class ContentLength
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+
+      if !Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status) &&
+         !headers['Content-Length'] &&
+         !headers['Transfer-Encoding'] &&
+         (body.respond_to?(:to_ary) || body.respond_to?(:to_str))
+
+        body = [body] if body.respond_to?(:to_str) # rack 0.4 compat
+        length = body.to_ary.inject(0) { |len, part| len + part.length }
+        headers['Content-Length'] = length.to_s
+      end
+
+      [status, headers, body]
+    end
+  end
+end

data/lib/gems/rack-0.9.1/lib/rack/deflater.rb

@@ -0,0 +1,87 @@
+require "zlib"
+require "stringio"
+require "time"  # for Time.httpdate
+
+module Rack
+
+class Deflater
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    status, headers, body = @app.call(env)
+    headers = Utils::HeaderHash.new(headers)
+
+    # Skip compressing empty entity body responses and responses with
+    # no-transform set.
+    if Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
+        headers['Cache-Control'].to_s =~ /\bno-transform\b/
+      return [status, headers, body]
+    end
+
+    request = Request.new(env)
+
+    encoding = Utils.select_best_encoding(%w(gzip deflate identity),
+                                          request.accept_encoding)
+
+    # Set the Vary HTTP header.
+    vary = headers["Vary"].to_s.split(",").map { |v| v.strip }
+    unless vary.include?("*") || vary.include?("Accept-Encoding")
+      headers["Vary"] = vary.push("Accept-Encoding").join(",")
+    end
+
+    case encoding
+    when "gzip"
+      mtime = if headers.key?("Last-Modified") 
+                Time.httpdate(headers["Last-Modified"]) 
+              else 
+                Time.now
+              end
+      [status,
+       headers.merge("Content-Encoding" => "gzip"),
+       self.class.gzip(body, mtime)]
+    when "deflate"
+      [status,
+       headers.merge("Content-Encoding" => "deflate"),
+       self.class.deflate(body)]
+    when "identity"
+      [status, headers, body]
+    when nil
+      message = ["An acceptable encoding for the requested resource #{request.fullpath} could not be found."]
+      [406, {"Content-Type" => "text/plain"}, message]
+    end
+  end
+
+  def self.gzip(body, mtime)
+    io = StringIO.new
+    gzip = Zlib::GzipWriter.new(io)
+    gzip.mtime = mtime
+
+    # TODO: Add streaming
+    body.each { |part| gzip << part }
+
+    gzip.close
+    return io.string
+  end
+
+  DEFLATE_ARGS = [
+    Zlib::DEFAULT_COMPRESSION,
+    # drop the zlib header which causes both Safari and IE to choke
+   -Zlib::MAX_WBITS,
+    Zlib::DEF_MEM_LEVEL,
+    Zlib::DEFAULT_STRATEGY
+  ]
+
+  # Loosely based on Mongrel's Deflate handler
+  def self.deflate(body)
+    deflater = Zlib::Deflate.new(*DEFLATE_ARGS)
+
+    # TODO: Add streaming
+    body.each { |part| deflater << part }
+
+    return deflater.finish
+  end
+end
+
+end

data/lib/gems/rack-0.9.1/lib/rack/directory.rb

@@ -0,0 +1,150 @@
+require 'time'
+require 'rack/mime'
+
+module Rack
+  # Rack::Directory serves entries below the +root+ given, according to the
+  # path info of the Rack request. If a directory is found, the file's contents
+  # will be presented in an html based index. If a file is found, the env will
+  # be passed to the specified +app+.
+  #
+  # If +app+ is not specified, a Rack::File of the same +root+ will be used.
+
+  class Directory
+    DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>"
+    DIR_PAGE = <<-PAGE
+<html><head>
+  <title>%s</title>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <style type='text/css'>
+table { width:100%%; }
+.name { text-align:left; }
+.size, .mtime { text-align:right; }
+.type { width:11em; }
+.mtime { width:15em; }
+  </style>
+</head><body>
+<h1>%s</h1>
+<hr />
+<table>
+  <tr>
+    <th class='name'>Name</th>
+    <th class='size'>Size</th>
+    <th class='type'>Type</th>
+    <th class='mtime'>Last Modified</th>
+  </tr>
+%s
+</table>
+<hr />
+</body></html>
+    PAGE
+
+    attr_reader :files
+    attr_accessor :root, :path
+
+    def initialize(root, app=nil)
+      @root = F.expand_path(root)
+      @app = app || Rack::File.new(@root)
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    F = ::File
+
+    def _call(env)
+      @env = env
+      @script_name = env['SCRIPT_NAME']
+      @path_info = Utils.unescape(env['PATH_INFO'])
+
+      if forbidden = check_forbidden
+        forbidden
+      else
+        @path = F.join(@root, @path_info)
+        list_path
+      end
+    end
+
+    def check_forbidden
+      return unless @path_info.include? ".."
+
+      body = "Forbidden\n"
+      size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+      return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
+    end
+
+    def list_directory
+      @files = [['../','Parent Directory','','','']]
+      glob = F.join(@path, '*')
+
+      Dir[glob].sort.each do |node|
+        stat = stat(node)
+        next  unless stat
+        basename = F.basename(node)
+        ext = F.extname(node)
+
+        url = F.join(@script_name, @path_info, basename)
+        size = stat.size
+        type = stat.directory? ? 'directory' : Mime.mime_type(ext)
+        size = stat.directory? ? '-' : filesize_format(size)
+        mtime = stat.mtime.httpdate
+
+        @files << [ url, basename, size, type, mtime ]
+      end
+
+      return [ 200, {'Content-Type'=>'text/html; charset=utf-8'}, self ]
+    end
+
+    def stat(node, max = 10)
+      F.stat(node)
+    rescue Errno::ENOENT, Errno::ELOOP
+      return nil
+    end
+
+    # TODO: add correct response if not readable, not sure if 404 is the best
+    #       option
+    def list_path
+      @stat = F.stat(@path)
+
+      if @stat.readable?
+        return @app.call(@env) if @stat.file?
+        return list_directory if @stat.directory?
+      else
+        raise Errno::ENOENT, 'No such file or directory'
+      end
+
+    rescue Errno::ENOENT, Errno::ELOOP
+      return entity_not_found
+    end
+
+    def entity_not_found
+      body = "Entity not found: #{@path_info}\n"
+      size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+      return [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]]
+    end
+
+    def each
+      show_path = @path.sub(/^#{@root}/,'')
+      files = @files.map{|f| DIR_FILE % f }*"\n"
+      page  = DIR_PAGE % [ show_path, show_path , files ]
+      page.each_line{|l| yield l }
+    end
+
+    # Stolen from Ramaze
+
+    FILESIZE_FORMAT = [
+      ['%.1fT', 1 << 40],
+      ['%.1fG', 1 << 30],
+      ['%.1fM', 1 << 20],
+      ['%.1fK', 1 << 10],
+    ]
+
+    def filesize_format(int)
+      FILESIZE_FORMAT.each do |format, size|
+        return format % (int.to_f / size) if int >= size
+      end
+
+      int.to_s + 'B'
+    end
+  end
+end