merb-core 0.9.2

data/lib/merb-core/core_ext/object.rb

@@ -0,0 +1,136 @@
+class Object
+  # Extracts the singleton class, so that metaprogramming can be done on it.
+  #
+  # ==== Returns
+  # Class:: The meta class.
+  #
+  # ==== Examples
+  #   class MyString < String; end
+  #
+  #   MyString.instance_eval do
+  #     define_method :foo do
+  #       puts self
+  #     end
+  #   end
+  #
+  #   MyString.meta_class.instance_eval do
+  #     define_method :bar do
+  #       puts self
+  #     end
+  #   end
+  # 
+  #   def String.add_meta_var(var)
+  #     self.meta_class.instance_eval do
+  #       define_method var do
+  #         puts "HELLO"
+  #       end
+  #     end
+  #   end
+  #
+  #   MyString.new("Hello").foo #=> "Hello"
+  #   MyString.new("Hello").bar
+  #     #=> NoMethodError: undefined method `bar' for "Hello":MyString
+  #   MyString.foo
+  #     #=> NoMethodError: undefined method `foo' for MyString:Class
+  #   MyString.bar
+  #     #=> MyString
+  #   String.bar
+  #     #=> NoMethodError: undefined method `bar' for String:Class
+  #
+  #   MyString.add_meta_var(:x)
+  #   MyString.x #=> HELLO
+  #
+  # As you can see, using #meta_class allows you to execute code (and here,
+  # define a method) on the metaclass itself. It also allows you to define
+  # class methods that can be run on subclasses, and then be able to execute
+  # code on the metaclass of the subclass (here MyString).
+  #
+  # In this case, we were able to define a class method (add_meta_var) on
+  # String that was executable by the MyString subclass. It was then able to
+  # define a method on the subclass by adding it to the MyString metaclass.
+  #
+  # For more information, you can check out _why's excellent article at:
+  # http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+  def meta_class() class << self; self end end
+
+  # ==== Returns
+  # Boolean::
+  #   True if the empty? is true or if the object responds to strip (e.g. a
+  #   String) and strip.empty? is true, or if !self is true.
+  #
+  # ==== Examples
+  #    [].blank?         #=>  true
+  #    [1].blank?        #=>  false
+  #    [nil].blank?      #=>  false
+  #    nil.blank?        #=>  true
+  #    true.blank?       #=>  false
+  #    false.blank?      #=>  true
+  #    "".blank?         #=>  true
+  #    "     ".blank?    #=>  true
+  #    " hey ho ".blank? #=>  false  
+  def blank?
+    if respond_to?(:empty?) && respond_to?(:strip)
+      empty? or strip.empty?
+    elsif respond_to?(:empty?)
+      empty?
+    else
+      !self
+    end
+  end
+
+  # ==== Parameters
+  # name<String>:: The name of the constant to get, e.g. "Merb::Router".
+  #
+  # ==== Returns
+  # Object:: The constant corresponding to the name.
+  def full_const_get(name)
+    list = name.split("::")
+    obj = Object
+    list.each {|x| obj = obj.const_get(x) }
+    obj
+  end
+  
+  # Makes a module from a string (e.g. Foo::Bar::Baz)
+  #
+  # ==== Parameters
+  # name<String>:: The name of the full module name to make
+  #
+  # ==== Returns
+  # nil
+  def make_module(str)
+    mod = str.split("::")
+    start = mod.map {|x| "module #{x}"}.join("; ")
+    ender = (["end"] * mod.size).join("; ")
+    self.class_eval <<-HERE
+      #{start}
+      #{ender}
+    HERE
+  end
+  
+  # ==== Parameters
+  # duck<Symbol, Class, Array>:: The thing to compare the object to.
+  #
+  # ==== Notes
+  # The behavior of the method depends on the type of duck as follows:
+  # Symbol:: Check whether the object respond_to?(duck).
+  # Class:: Check whether the object is_a?(duck).
+  # Array::
+  #   Check whether the object quacks_like? at least one of the options in the
+  #   array.
+  #
+  # ==== Returns
+  # Boolean:: True if the object quacks like duck.
+  def quacks_like?(duck)
+    case duck
+    when Symbol
+      self.respond_to?(duck)
+    when Class
+      self.is_a?(duck)
+    when Array
+      duck.any? {|d| self.quacks_like?(d) }
+    else
+      false
+    end
+  end
+
+end

data/lib/merb-core/core_ext/object_space.rb

@@ -0,0 +1,14 @@
+module ObjectSpace
+  
+  class << self
+
+    # ==== Returns
+    # Array[Class]:: All the classes in the object space.
+    def classes
+      klasses = []
+      ObjectSpace.each_object(Class) {|o| klasses << o}
+      klasses
+    end
+  end
+  
+end

data/lib/merb-core/core_ext/rubygems.rb

@@ -0,0 +1,28 @@
+# this is a temporary workaround until rubygems Does the Right thing here
+require 'rubygems'
+module Gem
+  class SourceIndex
+    
+    # Overwrite this so that a gem of the same name and version won't push one
+    # from the gems directory out entirely.
+    #
+    # ==== Parameters
+    # gem_spec<Gem::Specification>:: The specification of the gem to add.
+    def add_spec(gem_spec)
+      @gems[gem_spec.full_name] = gem_spec unless @gems[gem_spec.full_name].is_a?(Gem::Specification) && @gems[gem_spec.full_name].installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems")
+    end
+  end
+
+  class Specification
+
+    # Overwrite this so that gems in the gems directory get preferred over gems
+    # from any other location. If there are two gems of different versions in
+    # the gems directory, the later one will load as usual.
+    #
+    # ==== Returns
+    # Array[Array]:: The object used for sorting gem specs.
+    def sort_obj
+      [@name, installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems") ? 1 : -1, @version.to_ints, @new_platform == Gem::Platform::RUBY ? -1 : 1]
+    end
+  end
+end

data/lib/merb-core/core_ext/set.rb

@@ -0,0 +1,41 @@
+module Merb
+  class SimpleSet < Hash
+
+    # ==== Parameters
+    # arr<Array>:: Initial set values.
+    #
+    # ==== Returns
+    # Array:: The array the Set was initialized with
+    def initialize(arr = [])
+      arr.each {|x| self[x] = true}
+    end
+
+    # ==== Parameters
+    # value<Object>:: Value to add to set.
+    #
+    # ==== Returns
+    # true
+    def <<(value)
+      self[value] = true
+    end
+
+    # ==== Parameters
+    # arr<Array>:: Values to merge with set.
+    #
+    # ==== Returns
+    # SimpleSet:: The set after the Array was merged in.
+    def merge(arr)
+      super(arr.inject({}) {|s,x| s[x] = true; s })
+    end
+
+    # ==== Returns
+    # String:: A human readable version of the set.
+    def inspect
+      "#<SimpleSet: {#{keys.map {|x| x.inspect}.join(", ")}}>"
+    end
+  
+    # def to_a
+    alias_method :to_a, :keys
+    
+  end
+end

data/lib/merb-core/core_ext/string.rb

@@ -0,0 +1,69 @@
+require "pathname"
+
+class String
+  
+  class InvalidPathConversion < Exception; end
+
+  # ==== Returns
+  # String:: The string with all regexp special characters escaped.
+  #
+  # ==== Examples
+  #   "\*?{}.".escape_regexp #=> "\\*\\?\\{\\}\\."
+  def escape_regexp
+    Regexp.escape self
+  end
+  
+  # ==== Returns
+  # String:: The string converted to snake case.
+  #
+  # ==== Examples
+  #   "FooBar".snake_case #=> "foo_bar"
+  def snake_case
+    gsub(/\B[A-Z]/, '_\&').downcase
+  end
+
+  # ==== Returns
+  # String:: The string converted to camel case.
+  #
+  # ==== Examples
+  #   "foo_bar".camel_case #=> "FooBar"
+  def camel_case
+    split('_').map{|e| e.capitalize}.join
+  end
+  
+  # ==== Returns
+  # String:: The path string converted to a constant name.
+  #
+  # ==== Examples
+  #   "merb/core_ext/string".to_const_string #=> "Merb::CoreExt::String"
+  def to_const_string
+    gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+  
+  # ==== Returns
+  # String::
+  #   The path that is associated with the constantized string, assuming a
+  #   conventional structure.
+  #
+  # ==== Examples
+  #   "FooBar::Baz".to_const_path # => "foo_bar/baz"
+  def to_const_path
+    snake_case.gsub(/::/, "/")
+  end
+
+  # ==== Parameters
+  # o<String>:: The path component to join with the string.
+  #
+  # ==== Returns
+  # String:: The original path concatenated with o.
+  #
+  # ==== Examples
+  #   "merb"/"core_ext" #=> "merb/core_ext"
+  def /(o)
+    File.join(self, o.to_s)
+  end
+  
+  def relative_path_from(other)
+    Pathname.new(self).relative_path_from(Pathname.new(other)).to_s
+  end
+end

data/lib/merb-core/dispatch/cookies.rb

@@ -0,0 +1,92 @@
+module Merb
+
+  # Cookies are read and written through Merb::Controller#cookies. The cookies
+  # you read are those received in request along with those that have been set
+  # during the current request. The cookies you write will be sent out with the
+  # response. Cookies are read by value (so you won't get the cookie object
+  # itself back -- just the value it holds).
+  class Cookies
+
+    # ==== Parameters
+    # request_cookies<Hash>:: Initial cookie store.
+    # headers<Hash>:: The response headers.
+    def initialize(request_cookies, headers)
+      @_cookies = request_cookies
+      @_headers = headers
+    end
+
+    # ==== Parameters
+    # name<~to_s>:: Name of the cookie.
+    #
+    # ==== Returns
+    # String:: Value of the cookie.
+    def [](name)
+      @_cookies[name]
+    end
+
+    # ==== Parameters
+    # name<~to_s>:: Name of the cookie.
+    # options<Hash, ~to_s>:: Options for the cookie being set (see below).
+    #
+    # ==== Options (options)
+    # :value<~to_s>:: Value of the cookie
+    # :path<String>:: The path for which this cookie applies. Defaults to "/".
+    # :expires<Time>:: Cookie expiry date.
+    #
+    # ==== Alternatives
+    # If options is not a hash, it will be used as the cookie value directly.
+    #
+    # ==== Examples
+    #   cookies[:user] = "dave" # => Sets a simple session cookie
+    #   cookies[:token] = { :value => user.token, :expires => Time.now + 2.weeks }
+    #     # => Will set a cookie that expires in 2 weeks
+    def []=(name, options)
+      value = ''
+      if options.is_a?(Hash)
+        options = Mash.new(options)
+        value = options.delete(:value)
+      else
+        value = options
+        options = Mash.new
+      end
+      @_cookies[name] = value
+      set_cookie(name, Merb::Request.escape(value), options)
+      Merb.logger.info("Cookie set: #{name} => #{value} -- #{options.inspect}")
+      options
+    end
+
+    # Removes the cookie on the client machine by setting the value to an empty
+    # string and setting its expiration date into the past.
+    #
+    # ==== Parameters
+    # name<~to_s>:: Name of the cookie to delete.
+    # options<Hash>:: Additional options to pass to +set_cookie+.
+    def delete(name, options = {})
+      cookie = @_cookies.delete(name)
+      options = Mash.new(options)
+      options[:expires] = Time.at(0)
+      set_cookie(name, "", options)
+      Merb.logger.info("Cookie deleted: #{name} => #{cookie.inspect}")
+      cookie
+    end
+
+    private
+    # ==== Parameters
+    # name<~to_s>:: Name of the cookie.
+    # value<~to_s>:: Value of the cookie.
+    # options<Hash>:: Additional options for the cookie (see below).
+    #
+    # ==== Options (options)
+    # :path<String>:: The path for which this cookie applies. Defaults to "/".
+    # :expires<Time>:: Cookie expiry date.
+    def set_cookie(name, value, options)
+      options[:path] = '/' unless options[:path]
+      if expiry = options[:expires]
+        options[:expires] = expiry.gmtime.strftime(Merb::Const::COOKIE_EXPIRATION_FORMAT)
+      end
+      # options are sorted for testing purposes
+      (@_headers['Set-Cookie'] ||=[]) << "#{name}=#{value}; " +
+        options.map{|k, v| "#{k}=#{v};"}.sort.join(' ')
+    end
+  end
+end

data/lib/merb-core/dispatch/dispatcher.rb

@@ -0,0 +1,233 @@
+class Merb::Dispatcher
+  DEFAULT_ERROR_TEMPLATE = File.expand_path(File.dirname(__FILE__) / 'exceptions.html')
+  
+  class << self
+    
+    attr_accessor :use_mutex
+    
+    @@mutex = Mutex.new
+    Merb::Dispatcher.use_mutex = ::Merb::Config[:use_mutex]
+    
+    # This is where we grab the incoming request REQUEST_URI and use that in
+    # the merb RouteMatcher to determine which controller and method to run.
+    # Returns a 2 element tuple of: [controller, action]
+    #
+    # ControllerExceptions are rescued here and redispatched.
+    #
+    # ==== Parameters
+    # rack_env<Rack::Environment>::
+    #   The rack environment, which is used to instantiate a Merb::Request
+    # response<IO>::
+    #   An IO object to hold the response
+    #
+    # ==== Returns
+    # Array[Merb::Controller, Symbol]::
+    #   An array containing the Merb::Controller and the action that was
+    #   dispatched to.
+    def handle(rack_env)
+      start   = Time.now
+      request = Merb::Request.new(rack_env)
+      
+      route_index, route_params = Merb::Router.match(request)
+      
+      if route_params.empty?
+        raise ::Merb::ControllerExceptions::NotFound, "No routes match the request, #{request.uri}"
+      end
+      request.route_params = route_params
+      request.params.merge! route_params
+      
+      Merb.logger.info("Params: #{request.params.inspect}")
+      
+      controller_name = (route_params[:namespace] ? route_params[:namespace] + '/' : '') + route_params[:controller]
+      
+      unless controller_name
+        raise Merb::ControllerExceptions::NotFound, "Route matched, but route did not specify a controller" 
+      end
+      
+      Merb.logger.debug("Routed to: #{request.route_params.inspect}")
+
+      cnt = controller_name.snake_case.to_const_string
+      
+      if !Merb::Controller._subclasses.include?(cnt)
+        raise Merb::ControllerExceptions::NotFound, "Controller '#{cnt}' not found"
+      end
+      if cnt == "Application"
+        raise Merb::ControllerExceptions::NotFound, "The 'Application' controller has no public actions"
+      end
+
+      begin
+        klass = Object.full_const_get(cnt)
+      rescue NameError
+        raise Merb::ControllerExceptions::NotFound
+      end
+
+      action = route_params[:action]
+
+      controller = dispatch_action(klass, action, request)
+      controller._benchmarks[:dispatch_time] = Time.now - start
+      controller.route = Merb::Router.routes[route_index] if route_index
+      Merb.logger.info controller._benchmarks.inspect
+      Merb.logger.flush
+
+      controller
+    # this is the custom dispatch_exception; it allows failures to still be dispatched
+    # to the error controller
+    rescue => exception
+      Merb.logger.error(Merb.exception(exception))
+      unless request.xhr?
+        exception = controller_exception(exception)
+        dispatch_exception(request, exception)
+      else
+        Struct.new(:headers, :status, :body).new({}, 500,
+          <<-HERE
+#{exception.message}
+ 
+Params:
+#{(request.params || {}).map { |p,v| "  #{p}: #{v}\n"}.join("\n")}
+ 
+Session:
+#{(request.session || {}).map { |p,v| "  #{p}: #{v}\n"}.join("\n")}
+ 
+Cookies:
+#{(request.cookies || {}).map { |p,v| "  #{p}: #{v}\n"}.join("\n")}
+ 
+Stacktrace:
+#{exception.backtrace.join("\n")}
+          HERE
+        )
+      end
+    end
+    
+    private
+    # Setup the controller and call the chosen action 
+    #
+    # ==== Parameters
+    # klass<Merb::Controller>:: The controller class to dispatch to.
+    # action<Symbol>:: The action to dispatch.
+    # request<Merb::Request>::
+    #   The Merb::Request object that was created in #handle
+    # response<IO>:: The response object passed in from Mongrel
+    # status<Integer>:: The status code to respond with.
+    #
+    # ==== Returns
+    # Array[Merb::Controller, Symbol]::
+    #   An array containing the Merb::Controller and the action that was
+    #   dispatched to.
+    def dispatch_action(klass, action, request, status=200)
+      # build controller
+      controller = klass.new(request, status)
+      if use_mutex
+        @@mutex.synchronize { controller._dispatch(action) }
+      else
+        controller._dispatch(action)
+      end
+      controller
+    end
+    
+    # Re-route the current request to the Exception controller if it is
+    # available, and try to render the exception nicely.  
+    #
+    # You can handle exceptions by implementing actions for specific
+    # exceptions such as not_found or for entire classes of exceptions
+    # such as client_error
+    #
+    # If it is not available then just render a simple text error.
+    #
+    # ==== Parameters
+    # request<Merb::Request>:: 
+    #   The request object associated with the failed request.
+    # response<IO>::
+    #   The response object to put the response into.
+    # exception<Object>::
+    #   The exception object that was created when trying to dispatch the
+    #   original controller.
+    #
+    # ==== Returns
+    # Array[Merb::Controller, String]::
+    #   An array containing the Merb::Controller and the name of the exception
+    #   that triggrered #dispatch_exception. For instance, a NotFound exception
+    #   will be "not_found".
+    def dispatch_exception(request, exception)
+      exception_klass = exception.class
+      begin
+        klass = ::Exceptions rescue Merb::Controller
+        request.params[:original_params] = request.params.dup rescue {}
+        request.params[:original_session] = request.session.dup rescue {}
+        request.params[:original_cookies] = request.cookies.dup rescue {}
+        request.params[:exception] = exception
+        request.params[:action] = exception_klass.name
+      
+        dispatch_action(klass, exception_klass.name, request, exception.class::STATUS)
+      rescue => dispatch_issue
+        dispatch_issue = controller_exception(dispatch_issue)  
+        # when no action/template exist for an exception, or an
+        # exception occurs on an InternalServerError the message is
+        # rendered as simple text.
+        
+        # ControllerExceptions raised from exception actions are 
+        # dispatched back into the Exceptions controller
+        if dispatch_issue.is_a?(Merb::ControllerExceptions::NotFound)
+          # If a handler for a specific exception is not found, keep retrying 
+          # with the more general cases until we reach the base exception.
+          unless exception_klass == Merb::ControllerExceptions::Base
+            exception_klass = exception_klass.superclass
+            retry
+          else
+            dispatch_default_exception(klass, request, exception)
+          end
+        elsif dispatch_issue.is_a?(Merb::ControllerExceptions::InternalServerError)
+          dispatch_default_exception(klass, request, dispatch_issue)
+        else
+          exception = dispatch_issue
+          retry
+        end
+      end
+    end
+    
+    # If no custom actions are available to render an exception then the errors
+    # will end up here for processing
+    #
+    # ==== Parameters
+    # klass<Merb::Controller>:: 
+    #   The class of the controller to use for exception dispatch.
+    # request<Merb::Request>::
+    #   The Merb request that produced the original error.
+    # response<IO>::
+    #   The response object that the response will be put into.
+    # e<Exception>::
+    #   The exception that caused #dispatch_exception to be called.
+    #
+    # ==== Returns
+    # Array[Merb::Controller, String]::
+    #   An array containing the Merb::Controller that was dispatched to and the
+    #   error's name. For instance, a NotFound error's name is "not_found".
+    def dispatch_default_exception(klass, request, e)
+      controller = klass.new(request, e.class::STATUS)
+      if e.is_a? Merb::ControllerExceptions::Redirection
+        controller.headers.merge!('Location' => e.message)
+        controller.body = %{ } #fix
+      else
+        controller.instance_variable_set("@exception", e) # for ERB
+        controller.instance_variable_set("@exception_name", e.name.split("_").map {|x| x.capitalize}.join(" "))
+        controller.body = controller.send(Merb::Template.template_for(DEFAULT_ERROR_TEMPLATE))
+      end
+      controller
+    end
+    
+    # Wraps any non-ControllerException errors in an InternalServerError ready
+    # for displaying over HTTP.
+    #
+    # ==== Parameters
+    # e<Exception>::
+    #   The exception that caused #dispatch_exception to be called.
+    #
+    # ==== Returns
+    # Merb::InternalServerError::
+    #   An internal server error wrapper for the exception.
+    def controller_exception(e)
+      e.kind_of?(Merb::ControllerExceptions::Base) ?
+        e : Merb::ControllerExceptions::InternalServerError.new(e) 
+    end    
+    
+  end
+end