merb-core 1.0.15 → 1.1.0.pre

data/spec10/public/webrat/test_app/gems/gems/merb-core-0.9.14/lib/merb-core/controller/merb_controller.rb

@@ -0,0 +1,390 @@
+class Merb::Controller < Merb::AbstractController
+
+  class_inheritable_accessor :_hidden_actions, :_shown_actions
+
+  self._hidden_actions ||= []
+  self._shown_actions  ||= []
+
+  cattr_accessor :_subclasses
+  self._subclasses = Set.new
+
+  def self.subclasses_list() _subclasses end
+
+  include Merb::ResponderMixin
+  include Merb::ControllerMixin
+  include Merb::AuthenticationMixin
+  include Merb::ConditionalGetMixin
+
+  # ==== Parameters
+  # klass<Merb::Controller>::
+  #   The Merb::Controller inheriting from the base class.
+  #
+  # @api private
+  def self.inherited(klass)
+    _subclasses << klass.to_s
+    super
+    klass._template_root = Merb.dir_for(:view) unless self._template_root
+  end
+
+  # Hide each of the given methods from being callable as actions.
+  #
+  # ==== Parameters
+  # *names<~to-s>:: Actions that should be added to the list.
+  #
+  # ==== Returns
+  # Array[String]::
+  #   An array of actions that should not be possible to dispatch to.
+  #
+  # @api public
+  def self.hide_action(*names)
+    self._hidden_actions = self._hidden_actions | names.map { |n| n.to_s }
+  end
+
+  # Makes each of the given methods being callable as actions. You can use
+  # this to make methods included from modules callable as actions.
+  #
+  # ==== Parameters
+  # *names<~to-s>:: Actions that should be added to the list.
+  #
+  # ==== Returns
+  # Array[String]::
+  #   An array of actions that should be dispatched to even if they would not
+  #   otherwise be.
+  #
+  # ==== Example
+  #   module Foo
+  #     def self.included(base)
+  #       base.show_action(:foo)
+  #     end
+  #
+  #     def foo
+  #       # some actiony stuff
+  #     end
+  #
+  #     def foo_helper
+  #       # this should not be an action
+  #     end
+  #   end
+  #
+  # @api public
+  def self.show_action(*names)
+    self._shown_actions = self._shown_actions | names.map {|n| n.to_s}
+  end
+
+  # The list of actions that are callable, after taking defaults,
+  # _hidden_actions and _shown_actions into consideration. It is calculated
+  # once, the first time an action is dispatched for this controller.
+  #
+  # ==== Returns
+  # SimpleSet[String]:: A set of actions that should be callable.
+  #
+  # @api public
+  def self.callable_actions
+    @callable_actions ||= Extlib::SimpleSet.new(_callable_methods)
+  end
+
+  # This is a stub method so plugins can implement param filtering if they want.
+  #
+  # ==== Parameters
+  # params<Hash{Symbol => String}>:: A list of params
+  #
+  # ==== Returns
+  # Hash{Symbol => String}:: A new list of params, filtered as desired
+  # 
+  # @api plugin
+  # @overridable
+  def self._filter_params(params)
+    params
+  end
+
+  # All methods that are callable as actions.
+  #
+  # ==== Returns
+  # Array:: A list of method names that are also actions
+  #
+  # @api private
+  def self._callable_methods
+    callables = []
+    klass = self
+    begin
+      callables << (klass.public_instance_methods(false) + klass._shown_actions) - klass._hidden_actions
+      klass = klass.superclass
+    end until klass == Merb::AbstractController || klass == Object
+    callables.flatten.reject{|action| action =~ /^_.*/}
+  end
+
+  # The location to look for a template for a particular controller, context,
+  # and mime-type. This is overridden from AbstractController, which defines a
+  # version of this that does not involve mime-types.
+  #
+  # ==== Parameters
+  # context<~to_s>:: The name of the action or template basename that will be rendered.
+  # type<~to_s>::
+  #    The mime-type of the template that will be rendered. Defaults to nil.
+  # controller<~to_s>::
+  #   The name of the controller that will be rendered. Defaults to
+  #   controller_name.  This will be "layout" for rendering a layout.  
+  #
+  # ==== Notes
+  # By default, this renders ":controller/:action.:type". To change this,
+  # override it in your application class or in individual controllers.
+  #
+  # @api public
+  # @overridable
+  def _template_location(context, type, controller)
+    _conditionally_append_extension(controller ? "#{controller}/#{context}" : "#{context}", type)
+  end
+
+  # The location to look for a template and mime-type. This is overridden
+  # from AbstractController, which defines a version of this that does not
+  # involve mime-types.
+  #
+  # ==== Parameters
+  # template<String>::
+  #    The absolute path to a template - without mime and template extension.
+  #    The mime-type extension is optional - it will be appended from the
+  #    current content type if it hasn't been added already.
+  # type<~to_s>::
+  #    The mime-type of the template that will be rendered. Defaults to nil.
+  #
+  # @api public
+  def _absolute_template_location(template, type)
+    _conditionally_append_extension(template, type)
+  end
+
+  # Build a new controller.
+  #
+  # Sets the variables that came in through the dispatch as available to
+  # the controller.
+  #
+  # ==== Parameters
+  # request<Merb::Request>:: The Merb::Request that came in from Rack.
+  # status<Integer>:: An integer code for the status. Defaults to 200.
+  # headers<Hash{header => value}>::
+  #   A hash of headers to start the controller with. These headers can be
+  #   overridden later by the #headers method.
+  # 
+  # @api plugin
+  # @overridable
+  def initialize(request, status=200, headers={'Content-Type' => 'text/html; charset=utf-8'})
+    super()
+    @request, @_status, @headers = request, status, headers
+  end
+
+  # Dispatch the action.
+  #
+  # ==== Parameters
+  # action<~to_s>:: An action to dispatch to. Defaults to :index.
+  #
+  # ==== Returns
+  # String:: The string sent to the logger for time spent.
+  #
+  # ==== Raises
+  # ActionNotFound:: The requested action was not found in class.
+  #
+  # @api plugin
+  def _dispatch(action=:index)
+    Merb.logger.info("Params: #{self.class._filter_params(request.params).inspect}")
+    start = Time.now
+    if self.class.callable_actions.include?(action.to_s)
+      super(action)
+    else
+      raise ActionNotFound, "Action '#{action}' was not found in #{self.class}"
+    end
+    @_benchmarks[:action_time] = Time.now - start
+    self
+  end
+
+  attr_reader :request, :headers
+
+  # ==== Returns
+  # Fixnum:: The response status code
+  #
+  # @api public
+  def status
+    @_status
+  end
+
+  # Set the response status code.
+  #
+  # ==== Parameters
+  # s<Fixnum, Symbol>:: A status-code or named http-status
+  #
+  # @api public
+  def status=(s)
+    if s.is_a?(Symbol) && STATUS_CODES.key?(s)
+      @_status = STATUS_CODES[s]
+    elsif s.is_a?(Fixnum)
+      @_status = s
+    else
+      raise ArgumentError, "Status should be of type Fixnum or Symbol, was #{s.class}"
+    end
+  end
+
+  # ==== Returns
+  # Hash:: The parameters from the request object
+  # 
+  # @api public
+  def params()  request.params  end
+    
+  # There are three possible ways to use this method.  First, if you have a named route, 
+  # you can specify the route as the first parameter as a symbol and any paramters in a 
+  # hash.  Second, you can generate the default route by just passing the params hash, 
+  # just passing the params hash.  Finally, you can use the anonymous parameters.  This 
+  # allows you to specify the parameters to a named route in the order they appear in the 
+  # router.  
+  #
+  # ==== Parameters(Named Route)
+  # name<Symbol>:: 
+  #   The name of the route. 
+  # args<Hash>:: 
+  #   Parameters for the route generation.
+  #
+  # ==== Parameters(Default Route)
+  # args<Hash>:: 
+  #   Parameters for the route generation.  This route will use the default route. 
+  #
+  # ==== Parameters(Anonymous Parameters)
+  # name<Symbol>::
+  #   The name of the route.  
+  # args<Array>:: 
+  #   An array of anonymous parameters to generate the route
+  #   with. These parameters are assigned to the route parameters
+  #   in the order that they are passed.
+  #
+  # ==== Returns
+  # String:: The generated URL.
+  #
+  # ==== Examples
+  # Named Route
+  #
+  # Merb::Router.prepare do
+  #   match("/articles/:title").to(:controller => :articles, :action => :show).name("articles")
+  # end
+  #
+  # url(:articles, :title => "new_article")
+  #
+  # Default Route
+  #
+  # Merb::Router.prepare do
+  #   default_routes
+  # end
+  #
+  # url(:controller => "articles", :action => "new")
+  #
+  # Anonymous Paramters
+  #
+  # Merb::Router.prepare do
+  #   match("/articles/:year/:month/:title").to(:controller => :articles, :action => :show).name("articles")
+  # end
+  #
+  # url(:articles, 2008, 10, "test_article")
+  #
+  # @api public
+  def url(name, *args)
+    args << params
+    name = request.route if name == :this
+    Merb::Router.url(name, *args)
+  end
+  
+  # Generates a URL for a single or nested resource.
+  #
+  # ==== Parameters
+  # resources<Symbol,Object>:: The resources for which the URL
+  #   should be generated. These resources should be specified
+  #   in the router.rb file using #resources and #resource.
+  #
+  # options<Hash>:: Any extra parameters that are needed to
+  #   generate the URL.
+  #
+  # ==== Returns
+  # String:: The generated URL.
+  #
+  # ==== Examples
+  #
+  # Merb::Router.prepare do
+  #   resources :users do
+  #     resources :comments
+  #   end
+  # end
+  #
+  # resource(:users)            # => /users
+  # resource(@user)             # => /users/10
+  # resource(@user, :comments)  # => /users/10/comments
+  # resource(@user, @comment)   # => /users/10/comments/15
+  # resource(:users, :new)      # => /users/new
+  # resource(:@user, :edit)     # => /users/10/edit
+  #
+  # @api public
+  def resource(*args)
+    args << params
+    Merb::Router.resource(*args)
+  end
+  
+
+  alias_method :relative_url, :url
+  
+  # Returns the absolute url including the passed protocol and host.  
+  # 
+  # This uses the same arguments as the url method, with added requirements 
+  # of protocol and host options. 
+  #
+  # @api public
+  def absolute_url(*args)
+    options  = extract_options_from_args!(args) || {}
+    options[:protocol] ||= request.protocol
+    options[:host] ||= request.host
+    args << options
+    super(*args)
+  end
+
+  # The results of the controller's render, to be returned to Rack.
+  #
+  # ==== Returns
+  # Array[Integer, Hash, String]::
+  #   The controller's status code, headers, and body
+  #
+  # @api private
+  def rack_response
+    [status, headers, Merb::Rack::StreamWrapper.new(body)]
+  end
+
+  # Sets a controller to be "abstract" 
+  # This controller will not be able to be routed to
+  # and is used for super classing only
+  #
+  # @api public
+  def self.abstract!
+    @_abstract = true
+  end
+  
+  # Asks a controller if it is abstract
+  #
+  # === Returns
+  # Boolean
+  #  true if the controller has been set as abstract
+  #
+  # @api public
+  def self.abstract?
+    !!@_abstract 
+  end
+
+  # Hide any methods that may have been exposed as actions before.
+  hide_action(*_callable_methods)
+
+  private
+
+  # If not already added, add the proper mime extension to the template path.
+  #
+  # ==== Parameters
+  #
+  # template<~to_s> ::
+  #   The template path to append the mime type to.
+  # type<~to_s> ::
+  #   The extension to append to the template path conditionally
+  #
+  # @api private
+  def _conditionally_append_extension(template, type)
+    type && !template.match(/\.#{type.to_s.escape_regexp}$/) ? "#{template}.#{type}" : template
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/merb-core-0.9.14/lib/merb-core/controller/mime.rb

@@ -0,0 +1,135 @@
+module Merb
+  class << self
+
+    
+    # Returns a hash of the available mime types. 
+    #
+    # ==== Returns
+    # Hash{Symbol => Hash{Symbol => Object}}:: The available mime types.
+    #
+    # ==== Notes
+    # Each entry corresponds to a call to add_mime_type, having the mime type key (:html, :xml, :json, etc.)
+    # as the key and a hash containing the following entries:
+    #   :accepts           # the mime types that will be recognized by this entry
+    #   :transform_method  # the method called on an object to convert it to content of this type (such as to_json)
+    #   :content_type      # the value set to the "Content-Type" HTTP header when this mime is sent in a response
+    #   :response_headers  # sent in a response using this content type
+    #   :default_quality   # the scale factor used in describing content type preference
+    #   :response_block    # the block to be called with the controller when a request responds to this mime type
+    #
+    # @api public
+    def available_mime_types
+      ResponderMixin::TYPES
+    end
+
+    # ==== Returns
+    # Hash{String => Symbol}:: 
+    #   A hash mapping Content-Type values to the mime type key of the appropriate entry in #available_mime_types
+    #
+    # @api public
+    def available_accepts
+      ResponderMixin::MIMES
+    end
+
+    # Any specific outgoing headers should be included here.  These are not
+    # the content-type header but anything in addition to it.
+    # +transform_method+ should be set to a symbol of the method used to
+    # transform a resource into this mime type.
+    # For example for the :xml mime type an object might be transformed by
+    # calling :to_xml, or for the :js mime type, :to_json.
+    # If there is no transform method, use nil.
+    #
+    # ==== Autogenerated Methods
+    # Adding a mime-type adds a render_type method that sets the content
+    # type and calls render.
+    # 
+    # By default this does: def render_all, def render_yaml, def render_text,
+    # def render_html, def render_xml, def render_js, and def render_yaml
+    #
+    # ==== Parameters
+    # key<Symbol>:: The name of the mime-type. This is used by the provides API
+    # transform_method<~to_s>:: 
+    #   The associated method to call on objects to convert them to the
+    #   appropriate mime-type. For instance, :json would use :to_json as its
+    #   transform_method.
+    # mimes<Array[String]>::
+    #   A list of possible values sent in the Accept header, such as text/html,
+    #   that should be associated with this content-type.
+    # new_response_headers<Hash>::
+    #   The response headers to set for the the mime type. For example: 
+    #   'Content-Type' => 'application/json; charset=utf-8'; As a shortcut for
+    #   the common charset option, use :charset => 'utf-8', which will be
+    #   correctly appended to the mimetype itself.
+    # &block:: a block which recieves the current controller when the format
+    #   is set (in the controller's #content_type method)
+    #
+    # ==== Returns
+    # nil
+    #
+    # @api public
+    def add_mime_type(key, transform_method, mimes, new_response_headers = {}, default_quality = 1, &block) 
+      enforce!(key => Symbol, mimes => Array)
+      
+      content_type = new_response_headers["Content-Type"] || mimes.first
+      
+      if charset = new_response_headers.delete(:charset)
+        content_type += "; charset=#{charset}"
+      end
+      
+      ResponderMixin::TYPES.update(key => 
+        {:accepts           => mimes, 
+         :transform_method  => transform_method,
+         :content_type      => content_type,
+         :response_headers  => new_response_headers,
+         :default_quality   => default_quality,
+         :response_block    => block })
+
+      mimes.each do |mime|
+        ResponderMixin::MIMES.update(mime => key)
+      end
+
+      Merb::RenderMixin.class_eval <<-EOS, __FILE__, __LINE__
+        def render_#{key}(thing = nil, opts = {})
+          self.content_type = :#{key}
+          render thing, opts
+        end
+      EOS
+      
+      nil
+    end
+
+    # Removes a MIME-type from the mime-type list.
+    #
+    # ==== Parameters
+    # key<Symbol>:: The key that represents the mime-type to remove.
+    #
+    # ==== Returns
+    # (Boolean, Hash{Symbol => Object}):: If it was present, the old specification of the MIME-type. Same structure
+    #   as a value in Merb.available_mime_types. False if the key was not present.
+    #
+    # ==== Notes
+    # :all is the key for */*; It can't be removed.
+    #
+    # @api public
+    def remove_mime_type(key)
+      return false if key == :all
+      ResponderMixin::TYPES.delete(key)
+    end
+
+    # ==== Parameters
+    # key<Symbol>:: The key that represents the mime-type.
+    #
+    # ==== Returns
+    # Symbol:: The transform method for the mime type, e.g. :to_json.
+    #
+    # ==== Raises
+    # ArgumentError:: The requested mime type is not valid.
+    #
+    # @api private
+    def mime_transform_method(key)
+      raise ArgumentError, ":#{key} is not a valid MIME-type" unless ResponderMixin::TYPES.key?(key)
+      ResponderMixin::TYPES[key][:transform_method]
+    end
+
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/merb-core-0.9.14/lib/merb-core/controller/mixins/authentication.rb

@@ -0,0 +1,168 @@
+module Merb::AuthenticationMixin
+  
+  # Attempts to authenticate the user via HTTP Basic authentication. Takes a
+  # block with the username and password, if the block yields false the
+  # authentication is not accepted and :halt is thrown.
+  #
+  # If no block is passed, +basic_authentication+, the +request+ and +authenticate+
+  # methods can be chained. These can be used to independently request authentication
+  # or confirm it, if more control is desired.
+  #
+  # ==== Parameters
+  # realm<~to_s>:: The realm to authenticate against. Defaults to 'Application'.
+  # &authenticator:: A block to check if the authentication is valid.
+  #
+  # ==== Returns
+  # Merb::AuthenticationMixin::BasicAuthentication
+  #
+  # ==== Examples
+  #     class Application < Merb::Controller
+  #     
+  #       before :authenticate
+  #     
+  #       protected
+  #     
+  #       def authenticate
+  #         basic_authentication("My App") do |username, password|
+  #           password == "secret"
+  #         end
+  #       end
+  #     
+  #     end
+  #
+  #     class Application < Merb::Controller
+  #     
+  #       before :authenticate
+  #     
+  #       def authenticate
+  #         user = basic_authentication.authenticate do |username, password|
+  #           User.authenticate(username, password)
+  #         end
+  #     
+  #         if user
+  #           @current_user = user
+  #         else
+  #           basic_authentication.request
+  #         end
+  #       end
+  #     
+  #     end
+  #
+  # If you need to request basic authentication inside an action you need to use the request! method.
+  #
+  # ==== Example
+  #
+  #    class Sessions < Application
+  #  
+  #      def new
+  #        case content_type
+  #        when :html
+  #          render
+  #
+  #        else
+  #         user = basic_authentication.authenticate do |username, password|
+  #           User.authenticate(username, password)
+  #         end
+  #
+  #         if user
+  #           display(user)
+  #         else
+  #           basic_authentication.request
+  #         end
+  #        end
+  #      end
+  # 
+  #    end 
+  #
+  #
+  # @api public
+  def basic_authentication(realm = "Application", &authenticator)
+    @_basic_authentication ||= BasicAuthentication.new(self, realm, &authenticator)
+  end
+  
+  class BasicAuthentication
+    # So we can have access to the status codes
+    include Merb::ControllerExceptions
+
+    # @api private
+    def initialize(controller, realm = "Application", &authenticator)
+      @controller = controller
+      @realm = realm
+      @auth = Rack::Auth::Basic::Request.new(@controller.request.env)
+      authenticate_or_request(&authenticator) if authenticator
+    end
+
+    # Determines whether or not the user is authenticated using the criteria
+    # in the provided authenticator block.
+    #
+    # ==== Parameters
+    # &authenticator:: A block that decides whether the provided username and password
+    #   are valid.
+    #
+    # ==== Returns
+    # Object:: False if basic auth is not provided, otherwise the return value of the authenticator block.
+    def authenticate(&authenticator)
+      if @auth.provided? and @auth.basic?
+        authenticator.call(*@auth.credentials)
+      else
+        false
+      end
+    end
+
+    # Request basic authentication and halt the filter chain. This is for use in a before filter.
+    #
+    # ==== Throws
+    # :halt with an "HTTP Basic: Access denied." message with no layout, and sets the status to Unauthorized.
+    #
+    # @api public
+    def request
+      request!
+      throw :halt, @controller.render("HTTP Basic: Access denied.\n", :status => Unauthorized.status, :layout => false)
+    end
+    
+    # Sets headers to request basic auth.
+    #
+    # ==== Returns
+    # String:: Returns the empty string to provide a response body.
+    #
+    # @api public
+    def request!
+      @controller.status = Unauthorized.status
+      @controller.headers['WWW-Authenticate'] = 'Basic realm="%s"' % @realm
+      ""
+    end
+    
+    # ==== Returns
+    # Boolean:: Whether there has been any basic authentication credentials provided
+    #
+    # @api public
+    def provided?
+      @auth.provided?
+    end
+    
+    # ==== Returns
+    # String:: The username provided in the request.
+    #
+    # @api public
+    def username
+      provided? ? @auth.credentials.first : nil
+    end
+    
+    # ==== Returns
+    # String:: The password provided in the request.
+    #
+    # @api public
+    def password
+      provided? ? @auth.credentials.last : nil
+    end
+    
+    protected
+    
+    # @api private
+    def authenticate_or_request(&authenticator)
+      authenticate(&authenticator) || request
+    end
+    
+  end
+
+end