merb-core 0.9.4 → 0.9.5

data/lib/merb-core/logger.rb

@@ -1,202 +1,203 @@
-require "time" # httpdate
-# ==== Public Merb Logger API
-#
-# To replace an existing logger with a new one:
-#  Merb::Logger.set_log(log{String, IO},level{Symbol, String})
-#
-# Available logging levels are
-#   Merb::Logger::{ Fatal, Error, Warn, Info, Debug }
-#
-# Logging via:
-#   Merb.logger.fatal(message<String>,&block)
-#   Merb.logger.error(message<String>,&block)
-#   Merb.logger.warn(message<String>,&block)
-#   Merb.logger.info(message<String>,&block)
-#   Merb.logger.debug(message<String>,&block)
-#
-# Logging with autoflush:
-#   Merb.logger.fatal!(message<String>,&block)
-#   Merb.logger.error!(message<String>,&block)
-#   Merb.logger.warn!(message<String>,&block)
-#   Merb.logger.info!(message<String>,&block)
-#   Merb.logger.debug!(message<String>,&block)
-#
-# Flush the buffer to 
-#   Merb.logger.flush
-#
-# Remove the current log object
-#   Merb.logger.close
-# 
-# ==== Private Merb Logger API
-# 
-# To initialize the logger you create a new object, proxies to set_log.
-#   Merb::Logger.new(log{String, IO},level{Symbol, String})
-module Merb
-
-  class << self
-    attr_accessor :logger
-  end
-
-  class Logger
-
-    attr_accessor :level
-    attr_accessor :delimiter
-    attr_accessor :auto_flush
-    attr_reader   :buffer
-    attr_reader   :log
-    attr_reader   :init_args
-
-    # ==== Notes
-    # Ruby (standard) logger levels:
-    # :fatal:: An unhandleable error that results in a program crash
-    # :error:: A handleable error condition
-    # :warn:: A warning
-    # :info:: generic (useful) information about system operation
-    # :debug:: low-level information for developers
-    Levels = 
-    {
-      :fatal => 7, 
-      :error => 6, 
-      :warn  => 4,
-      :info  => 3,
-      :debug => 0
-    } unless const_defined?(:Levels)
-
-    private
-
-    # Readies a log for writing.
-    #
-    # ==== Parameters
-    # log<IO, String>:: Either an IO object or a name of a logfile.
-    def initialize_log(log)
-      close if @log # be sure that we don't leave open files laying around.
-
-      if log.respond_to?(:write)
-        @log = log
-      elsif File.exist?(log)
-        @log = open(log, (File::WRONLY | File::APPEND))
-        @log.sync = true
-      else
-        FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))
-        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
-        @log.sync = true
-        @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
-      end
-    end
-
-    public
-
-    # To initialize the logger you create a new object, proxies to set_log.
-    #
-    # ==== Parameters
-    # *args:: Arguments to create the log from. See set_logs for specifics.
-    def initialize(*args)
-      @init_args = args
-      set_log(*args)
-    end
-
-    # Replaces an existing logger with a new one.
-    # 
-    # ==== Parameters
-    # log<IO, String>:: Either an IO object or a name of a logfile.
-    # log_level<~to_sym>::
-    #   The log level from, e.g. :fatal or :info. Defaults to :error in the
-    #   production environment and :debug otherwise.
-    # delimiter<String>::
-    #   Delimiter to use between message sections. Defaults to " ~ ".
-    # auto_flush<Boolean>::
-    #   Whether the log should automatically flush after new messages are
-    #   added. Defaults to false.
-    def set_log(log, log_level = nil, delimiter = " ~ ", auto_flush = false)
-      if log_level && Levels[log_level.to_sym]
-        @level = Levels[log_level.to_sym]
-      elsif Merb.environment == "production"
-        @level = Levels[:warn]
-      else
-        @level = Levels[:debug]
-      end
-      @buffer     = []
-      @delimiter  = delimiter
-      @auto_flush = auto_flush
-
-      initialize_log(log)
-
-      Merb.logger = self
-    end
-
-    # Flush the entire buffer to the log object.
-    def flush
-      return unless @buffer.size > 0
-      @log.write(@buffer.slice!(0..-1).to_s)
-    end
-
-    # Close and remove the current log object.
-    def close
-      flush
-      @log.close if @log.respond_to?(:close) && !@log.tty?
-      @log = nil
-    end
-
-    # Appends a message to the log. The methods yield to an optional block and
-    # the output of this block will be appended to the message.
-    #
-    # ==== Parameters
-    # string<String>:: The message to be logged. Defaults to nil.
-    #
-    # ==== Returns
-    # String:: The resulting message added to the log file.
-    def <<(string = nil)
-      message = ""
-      message << delimiter
-      message << string if string
-      message << "\n" unless message[-1] == ?\n
-      @buffer << message
-      flush if @auto_flush
-
-      message
-    end
-    alias :push :<<
-
-    # Generate the logging methods for Merb.logger for each log level.
-    Levels.each_pair do |name, number|
-      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
-
-      # Appends a message to the log if the log level is at least as high as
-      # the log level of the logger.
-      #
-      # ==== Parameters
-      # string<String>:: The message to be logged. Defaults to nil.
-      #
-      # ==== Returns
-      # self:: The logger object for chaining.
-      def #{name}(message = nil)
-        self << message if #{number} >= level
-        self
-      end
-
-      # Appends a message to the log if the log level is at least as high as
-      # the log level of the logger. The bang! version of the method also auto
-      # flushes the log buffer to disk.
-      #
-      # ==== Parameters
-      # string<String>:: The message to be logged. Defaults to nil.
-      #
-      # ==== Returns
-      # self:: The logger object for chaining.
-      def #{name}!(message = nil)
-        self << message if #{number} >= level
-        flush if #{number} >= level
-        self
-      end
-
-      # ==== Returns
-      # Boolean:: True if this level will be logged by this logger.
-      def #{name}?
-        #{number} >= level
-      end
-      LEVELMETHODS
-    end
-
-  end
-  
-end
+Merb::Logger = Extlib::Logger
+# require "time" # httpdate
+# # ==== Public Merb Logger API
+# #
+# # To replace an existing logger with a new one:
+# #  Merb::Logger.set_log(log{String, IO},level{Symbol, String})
+# #
+# # Available logging levels are
+# #   Merb::Logger::{ Fatal, Error, Warn, Info, Debug }
+# #
+# # Logging via:
+# #   Merb.logger.fatal(message<String>,&block)
+# #   Merb.logger.error(message<String>,&block)
+# #   Merb.logger.warn(message<String>,&block)
+# #   Merb.logger.info(message<String>,&block)
+# #   Merb.logger.debug(message<String>,&block)
+# #
+# # Logging with autoflush:
+# #   Merb.logger.fatal!(message<String>,&block)
+# #   Merb.logger.error!(message<String>,&block)
+# #   Merb.logger.warn!(message<String>,&block)
+# #   Merb.logger.info!(message<String>,&block)
+# #   Merb.logger.debug!(message<String>,&block)
+# #
+# # Flush the buffer to 
+# #   Merb.logger.flush
+# #
+# # Remove the current log object
+# #   Merb.logger.close
+# # 
+# # ==== Private Merb Logger API
+# # 
+# # To initialize the logger you create a new object, proxies to set_log.
+# #   Merb::Logger.new(log{String, IO},level{Symbol, String})
+# module Merb
+# 
+#   class << self
+#     attr_accessor :logger
+#   end
+# 
+#   class Logger
+# 
+#     attr_accessor :level
+#     attr_accessor :delimiter
+#     attr_accessor :auto_flush
+#     attr_reader   :buffer
+#     attr_reader   :log
+#     attr_reader   :init_args
+# 
+#     # ==== Notes
+#     # Ruby (standard) logger levels:
+#     # :fatal:: An unhandleable error that results in a program crash
+#     # :error:: A handleable error condition
+#     # :warn:: A warning
+#     # :info:: generic (useful) information about system operation
+#     # :debug:: low-level information for developers
+#     Levels = 
+#     {
+#       :fatal => 7, 
+#       :error => 6, 
+#       :warn  => 4,
+#       :info  => 3,
+#       :debug => 0
+#     } unless const_defined?(:Levels)
+# 
+#     private
+# 
+#     # Readies a log for writing.
+#     #
+#     # ==== Parameters
+#     # log<IO, String>:: Either an IO object or a name of a logfile.
+#     def initialize_log(log)
+#       close if @log # be sure that we don't leave open files laying around.
+# 
+#       if log.respond_to?(:write)
+#         @log = log
+#       elsif File.exist?(log)
+#         @log = open(log, (File::WRONLY | File::APPEND))
+#         @log.sync = true
+#       else
+#         FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))
+#         @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
+#         @log.sync = true
+#         @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
+#       end
+#     end
+# 
+#     public
+# 
+#     # To initialize the logger you create a new object, proxies to set_log.
+#     #
+#     # ==== Parameters
+#     # *args:: Arguments to create the log from. See set_logs for specifics.
+#     def initialize(*args)
+#       @init_args = args
+#       set_log(*args)
+#     end
+# 
+#     # Replaces an existing logger with a new one.
+#     # 
+#     # ==== Parameters
+#     # log<IO, String>:: Either an IO object or a name of a logfile.
+#     # log_level<~to_sym>::
+#     #   The log level from, e.g. :fatal or :info. Defaults to :error in the
+#     #   production environment and :debug otherwise.
+#     # delimiter<String>::
+#     #   Delimiter to use between message sections. Defaults to " ~ ".
+#     # auto_flush<Boolean>::
+#     #   Whether the log should automatically flush after new messages are
+#     #   added. Defaults to false.
+#     def set_log(log, log_level = nil, delimiter = " ~ ", auto_flush = false)
+#       if log_level && Levels[log_level.to_sym]
+#         @level = Levels[log_level.to_sym]
+#       elsif Merb.environment == "production"
+#         @level = Levels[:warn]
+#       else
+#         @level = Levels[:debug]
+#       end
+#       @buffer     = []
+#       @delimiter  = delimiter
+#       @auto_flush = auto_flush
+# 
+#       initialize_log(log)
+# 
+#       Merb.logger = self
+#     end
+# 
+#     # Flush the entire buffer to the log object.
+#     def flush
+#       return unless @buffer.size > 0
+#       @log.write(@buffer.slice!(0..-1).to_s)
+#     end
+# 
+#     # Close and remove the current log object.
+#     def close
+#       flush
+#       @log.close if @log.respond_to?(:close) && !@log.tty?
+#       @log = nil
+#     end
+# 
+#     # Appends a message to the log. The methods yield to an optional block and
+#     # the output of this block will be appended to the message.
+#     #
+#     # ==== Parameters
+#     # string<String>:: The message to be logged. Defaults to nil.
+#     #
+#     # ==== Returns
+#     # String:: The resulting message added to the log file.
+#     def <<(string = nil)
+#       message = ""
+#       message << delimiter
+#       message << string if string
+#       message << "\n" unless message[-1] == ?\n
+#       @buffer << message
+#       flush if @auto_flush
+# 
+#       message
+#     end
+#     alias :push :<<
+# 
+#     # Generate the logging methods for Merb.logger for each log level.
+#     Levels.each_pair do |name, number|
+#       class_eval <<-LEVELMETHODS, __FILE__, __LINE__
+# 
+#       # Appends a message to the log if the log level is at least as high as
+#       # the log level of the logger.
+#       #
+#       # ==== Parameters
+#       # string<String>:: The message to be logged. Defaults to nil.
+#       #
+#       # ==== Returns
+#       # self:: The logger object for chaining.
+#       def #{name}(message = nil)
+#         self << message if #{number} >= level
+#         self
+#       end
+# 
+#       # Appends a message to the log if the log level is at least as high as
+#       # the log level of the logger. The bang! version of the method also auto
+#       # flushes the log buffer to disk.
+#       #
+#       # ==== Parameters
+#       # string<String>:: The message to be logged. Defaults to nil.
+#       #
+#       # ==== Returns
+#       # self:: The logger object for chaining.
+#       def #{name}!(message = nil)
+#         self << message if #{number} >= level
+#         flush if #{number} >= level
+#         self
+#       end
+# 
+#       # ==== Returns
+#       # Boolean:: True if this level will be logged by this logger.
+#       def #{name}?
+#         #{number} >= level
+#       end
+#       LEVELMETHODS
+#     end
+# 
+#   end
+#   
+# end

data/lib/merb-core/rack/application.rb

@@ -6,13 +6,27 @@ module Merb
         begin
           controller = ::Merb::Dispatcher.handle(Merb::Request.new(env))
         rescue Object => e
-          return [500, {"Content-Type"=>"text/html"}, e.message + "<br/>" + e.backtrace.join("<br/>")]
+          return [500, {Merb::Const::CONTENT_TYPE => "text/html"}, e.message + "<br/>" + e.backtrace.join("<br/>")]
         end
         Merb.logger.info "\n\n"
         Merb.logger.flush
+
+        unless controller.headers[Merb::Const::DATE]
+          require "time"
+          controller.headers[Merb::Const::DATE] = Time.now.rfc2822.to_s
+        end
         controller.rack_response
       end
-      
-    end
-  end  
-end
+
+      def deferred?(env)
+        path = env[Merb::Const::PATH_INFO] ? env[Merb::Const::PATH_INFO].chomp('/') : ""
+        if path =~ Merb.deferred_actions
+          Merb.logger.info! "Deferring Request: #{path}"
+          true
+        else
+          false
+        end        
+      end # deferred?(env)
+    end # Application
+  end # Rack
+end # Merb

data/lib/merb-core/rack/middleware/conditional_get.rb

@@ -0,0 +1,23 @@
+module Merb
+  module Rack
+
+    class ConditionalGet < Merb::Rack::Middleware
+      def call(env)
+        status, headers, body = @app.call(env)
+
+        # set Date header using RFC1123 date format as specified by HTTP
+        # RFC2616 section 3.3.1.
+        if etag = headers['ETag']
+          status = 304 if etag == env[Merb::Const::HTTP_IF_NONE_MATCH]
+        end
+
+        if last_modified = headers[Merb::Const::LAST_MODIFIED]
+          status = 304 if last_modified == env[Merb::Const::HTTP_IF_MODIFIED_SINCE]
+        end
+        
+        [status, headers, body]
+      end
+    end
+    
+  end
+end

data/lib/merb-core/rack/middleware/content_length.rb

@@ -0,0 +1,18 @@
+module Merb
+  module Rack
+
+    class ContentLength < Merb::Rack::Middleware
+      def call(env)
+        status, headers, body = @app.call(env)
+
+        # to_s is because Rack spec expects header
+        # values to be iterable and yield strings
+        header = 'Content-Length'.freeze
+        headers[header] = body.size.to_s unless headers.has_key?(header)
+
+        [status, headers, body]
+      end
+    end
+    
+  end
+end

data/lib/merb-core/rack/middleware/tracer.rb

@@ -0,0 +1,20 @@
+module Merb
+  module Rack
+    class Tracer < Merb::Rack::Middleware
+
+      def call(env)
+
+        Merb.logger.debug!("Rack environment:\n" + env.inspect + "\n\n")
+
+        status, headers, body = @app.call(env)
+
+        Merb.logger.debug!("Status: #{status.inspect}")
+        Merb.logger.debug!("Headers: #{headers.inspect}")
+        Merb.logger.debug!("Body: #{body.inspect}")
+
+        [status, headers, body]
+      end
+      
+    end
+  end
+end

data/lib/merb-core/rack/middleware.rb

@@ -7,13 +7,7 @@ module Merb
       end
       
       def deferred?(env)
-        path = env['PATH_INFO'] ? env['PATH_INFO'].chomp('/') : ""
-        if path =~ Merb.deferred_actions
-          Merb.logger.info! "Deferring Request: #{path}"
-          true
-        else
-          false
-        end
+        @app.deferred?(env)
       end
   
       def call(env)

data/lib/merb-core/rack.rb

@@ -1,21 +1,24 @@
 require 'rack'
 module Merb
   module Rack
-    autoload :Application,         'merb-core' / 'rack' / 'application'
-    autoload :Adapter,             'merb-core' / 'rack' / 'adapter'
-    autoload :Ebb,                 'merb-core' / 'rack' / 'adapter' / 'ebb'
-    autoload :EventedMongrel,      'merb-core' / 'rack' / 'adapter' / 'evented_mongrel'    
-    autoload :FastCGI,             'merb-core' / 'rack' / 'adapter' / 'fcgi'
-    autoload :Irb,                 'merb-core' / 'rack' / 'adapter' / 'irb'
-    autoload :Middleware,          'merb-core' / 'rack' / 'middleware'
-    autoload :Mongrel,             'merb-core' / 'rack' / 'adapter' / 'mongrel'
-    autoload :Runner,              'merb-core' / 'rack' / 'adapter' / 'runner'    
-    autoload :SwiftipliedMongrel,  'merb-core' / 'rack' / 'adapter' / 'swiftiplied_mongrel'
-    autoload :Thin,                'merb-core' / 'rack' / 'adapter' / 'thin'
-    autoload :ThinTurbo,           'merb-core' / 'rack' / 'adapter' / 'thin_turbo'
-    autoload :WEBrick,             'merb-core' / 'rack' / 'adapter' / 'webrick'
-    autoload :PathPrefix,          'merb-core' / 'rack' / 'middleware' / 'path_prefix'
-    autoload :Static,              'merb-core' / 'rack' / 'middleware' / 'static'
-    autoload :Profiler,            'merb-core' / 'rack' / 'middleware' / 'profiler'    
+    autoload :Application,         'merb-core/rack/application'
+    autoload :Adapter,             'merb-core/rack/adapter'
+    autoload :Ebb,                 'merb-core/rack/adapter/ebb'
+    autoload :EventedMongrel,      'merb-core/rack/adapter/evented_mongrel'    
+    autoload :FastCGI,             'merb-core/rack/adapter/fcgi'
+    autoload :Irb,                 'merb-core/rack/adapter/irb'
+    autoload :Middleware,          'merb-core/rack/middleware'
+    autoload :Mongrel,             'merb-core/rack/adapter/mongrel'
+    autoload :Runner,              'merb-core/rack/adapter/runner'    
+    autoload :SwiftipliedMongrel,  'merb-core/rack/adapter/swiftiplied_mongrel'
+    autoload :Thin,                'merb-core/rack/adapter/thin'
+    autoload :ThinTurbo,           'merb-core/rack/adapter/thin_turbo'
+    autoload :WEBrick,             'merb-core/rack/adapter/webrick'
+    autoload :PathPrefix,          'merb-core/rack/middleware/path_prefix'
+    autoload :Static,              'merb-core/rack/middleware/static'
+    autoload :Profiler,            'merb-core/rack/middleware/profiler'
+    autoload :Tracer,              'merb-core/rack/middleware/tracer'
+    autoload :ContentLength,       'merb-core/rack/middleware/content_length'
+    autoload :ConditionalGet,      'merb-core/rack/middleware/conditional_get'
   end # Rack
 end # Merb

data/lib/merb-core/test/matchers/route_matchers.rb

@@ -99,6 +99,7 @@ module Merb::Test::Rspec::RouteMatchers
     def matches?(parameter_hash)
       @actual = parameter_hash.dup.except(:controller, :action)
 
+      return @actual.empty? if @expected.empty?
       @expected.all? {|(k, v)| @actual.has_key?(k) && @actual[k] == v}
     end
 

data/lib/merb-core/test/matchers/view_matchers.rb

@@ -1,4 +1,34 @@
 module Merb::Test::Rspec::ViewMatchers
+  class HaveXpath
+    def initialize(expected)
+      @expected = expected
+    end
+    
+    def matches?(stringlike)
+      @document = case stringlike
+      when LibXML::XML::Document, LibXML::XML::Node
+        stringlike
+      when StringIO
+        LibXML::XML::HTMLParser.string(stringlike.string).parse
+      else
+        LibXML::XML::HTMLParser.string(stringlike).parse
+      end
+      !@document.find(@expected).empty?
+    end
+    
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected following text to match xpath #{@expected}:\n#{@document}"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected following text to not match xpath #{@expected}:\n#{@document}"
+    end    
+  end
+  
   class HaveSelector
 
     # ==== Parameters
@@ -302,6 +332,12 @@ module Merb::Test::Rspec::ViewMatchers
   end
   alias_method :match_selector, :have_selector
 
+  def have_xpath(expected)
+    require "libxml"
+    HaveXpath.new(expected)
+  end
+  alias_method :match_xpath, :have_xpath
+
   # RSpec matcher to test for the presence of tags.
   #
   # ==== Parameters

data/lib/merb-core/test/run_specs.rb

@@ -9,7 +9,7 @@ require 'benchmark'
 # spec_cmd<~to_s>:: The spec command. Defaults to "spec".
 # run_opts<String>:: Options to pass to spec commands, for instance,
 #                    if you want to use profiling formatter.
-def run_specs(globs, spec_cmd='spec', run_opts = "-c -f s")
+def run_specs(globs, spec_cmd='spec', run_opts = "-c")
   require "optparse"
   require "spec"
   globs = globs.is_a?(Array) ? globs : [globs]
@@ -18,6 +18,7 @@ def run_specs(globs, spec_cmd='spec', run_opts = "-c -f s")
   time = Benchmark.measure do
     globs.each do |glob|
       Dir[glob].each do |spec|
+        STDOUT.puts "\n\nRunning #{spec}...\n"
         response = Open3.popen3("#{spec_cmd} #{File.expand_path(spec)} #{run_opts}") do |i,o,e|
           while out = o.gets
             STDOUT.puts out

data/lib/merb-core/version.rb

@@ -1,5 +1,5 @@
 module Merb
-  VERSION = '0.9.4' unless defined?(Merb::VERSION)
+  VERSION = '0.9.5' unless defined?(Merb::VERSION)
 
   # Merb::RELEASE meanings:
   # 'dev'   : unreleased