merb 0.5.3 → 0.9.2

data/lib/merb/constants.rb

@@ -1,50 +0,0 @@
-module Merb
-  module Const
-    
-    ESCAPE_TABLE = {
-      '&' => '&',
-      '<' => '&lt;',
-      '>' => '&gt;',
-      '"' => '&quot;',
-      "'" => '&#039;',
-    }.freeze
-    
-    DEFAULT_SEND_FILE_OPTIONS = {
-      :type         => 'application/octet-stream'.freeze,
-      :disposition  => 'attachment'.freeze
-    }.freeze
-    
-    SET_COOKIE = " %s=%s; path=/; expires=%s".freeze
-    COOKIE_EXPIRATION_FORMAT = "%a, %d-%b-%Y %H:%M:%S GMT".freeze
-    COOKIE_SPLIT = /[;,] */n.freeze
-    COOKIE_REGEXP = /\s*(.+)=(.*)\s*/.freeze
-    COOKIE_EXPIRED_TIME  = Time.at(0).freeze
-    HOUR = 60*60
-    DAY = HOUR*24
-    WEEK = DAY*7
-    MULTIPART_REGEXP = /\Amultipart\/form-data.*boundary=\"?([^\";,]+)/n.freeze
-    HTTP_COOKIE            = 'HTTP_COOKIE'.freeze
-    QUERY_STRING           = 'QUERY_STRING'.freeze
-    JSON_MIME_TYPE_REGEXP  = %r{^application/json|^text/x-json}.freeze
-    XML_MIME_TYPE_REGEXP   = %r{^application/xml|^text/xml}.freeze
-    FORM_URL_ENCODED_REGEXP = %r{^application/x-www-form-urlencoded}.freeze
-    UPCASE_CONTENT_TYPE    = 'CONTENT_TYPE'.freeze
-    CONTENT_TYPE           = "Content-Type".freeze
-    LAST_MODIFIED          = "Last-Modified".freeze
-    SLASH                  = "/".freeze
-    REQUEST_METHOD         = "REQUEST_METHOD".freeze
-    GET                    = "GET".freeze
-    POST                   = "POST".freeze
-    HEAD                   = "HEAD".freeze
-    CONTENT_LENGTH         = "CONTENT_LENGTH".freeze
-    HTTP_X_FORWARDED_FOR   = "HTTP_X_FORWARDED_FOR".freeze
-    HTTP_IF_MODIFIED_SINCE = "HTTP_IF_MODIFIED_SINCE".freeze
-    HTTP_IF_NONE_MATCH     = "HTTP_IF_NONE_MATCH".freeze
-    UPLOAD_ID              = "upload_id".freeze
-    PATH_INFO              = "PATH_INFO".freeze
-    SCRIPT_NAME            = "SCRIPT_NAME".freeze
-    REQUEST_URI            = "REQUEST_URI".freeze
-    REQUEST_PATH           = "REQUEST_PATH".freeze
-    REMOTE_ADDR            = "REMOTE_ADDR".freeze
-  end
-end

data/lib/merb/controller.rb

@@ -1,220 +0,0 @@
-module Merb
-  
-  # All of your web controllers will inherit from Merb::Controller. This 
-  # superclass takes care of parsing the incoming headers and body into 
-  # params and cookies and headers. If the request is a file upload it will
-  # stream it into a tempfile and pass in the filename and tempfile object
-  # to your controller via params. It also parses the ?query=string and
-  # puts that into params as well.
-  #
-  # == Sessions
-  # 
-  # Session data can be accessed through the +session+ hash:
-  #
-  #   session[:user_id] = @user.id
-  #
-  # Session data is available until the user's cookie gets deleted/expires,
-  # or until your specific session store expires the data.
-  #
-  # === Session Store
-  #
-  # The session store is set in Merb.root/config/merb.yml :
-  #
-  #   :session_store: your_store
-  #
-  # Out of the box merb supports three session stores
-  #
-  # cookie:: All data (max 4kb) stored directly in cookie.  Data integrity is checked on each request to prevent tampering. (Merb::CookieStore)
-  # memory:: Data stored in a class in memory. (Merb::MemorySession)
-  # mem_cache:: Data stored in mem_cache. (Merb::MemCacheSession)
-  #
-  # See the documentation on each session store for more information.
-  #
-  # You can also use a session store provided by a plugin.  For instance, if you have DataMapper you can set
-  #
-  #   :session_store: datamapper
-  #
-  # In this case session data will be stored in the database, as defined by the merb_datamapper plugin.
-  # Similar functionality exists for +activerecord+ and +sequel+ currently.
-  
-  class Controller < AbstractController
-    class_inheritable_accessor :_session_id_key, :_session_expiry
-    cattr_accessor :_subclasses, :session_secret_key
-    self._subclasses = []
-    self.session_secret_key = nil
-    self._session_id_key = '_session_id'
-    self._session_expiry = Time.now + Merb::Const::WEEK * 2
-
-    include Merb::ControllerMixin
-    include Merb::ResponderMixin
-    include Merb::ControllerExceptions
-    include Merb::Caching::Actions
-        
-    class << self
-      def inherited(klass)
-        _subclasses << klass.to_s unless _subclasses.include?(klass.to_s)
-        super
-      end      
-      
-      def callable_actions
-        @callable_actions ||= begin
-          hsh = {}
-          (public_instance_methods - hidden_actions).each {|action| hsh[action.to_s] = true}
-          hsh
-        end
-      end
-      
-      def hidden_actions
-        write_inheritable_attribute(:hidden_actions, Merb::Controller.public_instance_methods) unless read_inheritable_attribute(:hidden_actions)
-        read_inheritable_attribute(:hidden_actions)
-      end
-      
-      # Hide each of the given methods from being callable as actions.
-      def hide_action(*names)
-        write_inheritable_attribute(:hidden_actions, hidden_actions | names.collect { |n| n.to_s })
-      end
-      
-      def build(request, response = StringIO.new, status=200, headers={'Content-Type' => 'text/html; charset=utf-8'})
-        cont = new
-        cont.set_dispatch_variables(request, response, status, headers)
-        cont
-      end
-    end
-    
-    def set_dispatch_variables(request, response, status, headers)
-      if request.params.key?(_session_id_key)
-        if Merb::Config[:session_id_cookie_only]
-          # This condition allows for certain controller/action paths to allow
-          # a session ID to be passed in a query string. This is needed for
-          # Flash Uploads to work since flash will not pass a Session Cookie
-          # Recommend running session.regenerate after any controller taking
-          # advantage of this in case someone is attempting a session fixation
-          # attack
-          if Merb::Config[:query_string_whitelist].include?("#{request.controller_name}/#{request.action}")
-          # FIXME to use routes not controller and action names -----^
-            request.cookies[_session_id_key] = request.params[_session_id_key]
-          end
-        else
-          request.cookies[_session_id_key] = request.params[_session_id_key]
-        end
-      end
-      @_request  = request
-      @_response = response
-      @_status   = status
-      @_headers  = headers
-    end
-    
-    def dispatch(action=:index)
-      start = Time.now    
-      if self.class.callable_actions[action.to_s]
-        params[:action] ||= action
-        setup_session
-        super(action)
-        finalize_session
-      else
-        raise ActionNotFound, "Action '#{action}' was not found in #{self.class}"
-      end
-      @_benchmarks[:action_time] = Time.now - start
-      Merb.logger.info("Time spent in #{self.class}##{action} action: #{@_benchmarks[:action_time]} seconds")
-    end
-      
-    # Accessor for @_body. Please use body and never @body directly.
-    def body
-       @_body  
-    end
-    
-    # Accessor for @_status. Please use status and never @_status directly.
-    def status
-       @_status
-    end
-    
-    # Accessor for @_request. Please use request and never @_request directly.
-    def request
-       @_request
-    end
-    
-    def params
-      request.params
-    end
-    
-    def cookies
-      @_cookies ||= Cookies.new(request.cookies, @_headers)
-    end
-    
-    # Accessor for @_headers. Please use headers and never @_headers directly.
-    def headers
-      @_headers
-    end
-    
-    # Accessor for @_session. Please use session and never @_session directly.    
-    def session
-      request.session
-    end
-    
-    # Accessor for @_response. Please use response and never @_response directly.
-    def response
-      @_response
-    end
-
-    # Accessor for @_route. Please use route and never @_route directly.
-    def route
-      request.route
-    end
-    
-    # Sends mail via a MailController (a tutorial can be found in the
-    # MailController docs).
-    # 
-    #  send_mail FooMailer, :bar, :from => "foo@bar.com", :to => "baz@bat.com"
-    # 
-    # would send an email via the FooMailer's bar method.
-    # 
-    # The mail_params hash would be sent to the mailer, and includes items
-    # like from, to subject, and cc. See
-    # Merb::MailController#dispatch_and_deliver for more details.
-    # 
-    # The send_params hash would be sent to the MailController, and is
-    # available to methods in the MailController as <tt>params</tt>. If you do
-    # not send any send_params, this controller's params will be available to
-    # the MailController as <tt>params</tt>
-    def send_mail(klass, method, mail_params, send_params = nil)
-      klass.new(send_params || params, self).dispatch_and_deliver(method, mail_params)
-    end
-    
-    # Dispatches a PartController. Use like:
-    # 
-    #   <%= part TodoPart => :list %>
-    #
-    # will instantiate a new TodoPart controller and call the :list action
-    # invoking the Part's before and after filters as part of the call.
-    #
-    # returns a string containing the results of the Part controllers dispatch
-    #
-    # You can compose parts easily as well, these two parts will stil be wrapped
-    # in the layout of the Foo controller:
-    #
-    # class Foo < Application
-    #   def some_action
-    #     wrap_layout(part(TodoPart => :new) + part(TodoPart => :list))
-    #   end
-    # end
-    #
-    def part(opts={})
-      res = opts.inject([]) do |memo,(klass,action)|
-        memo << klass.new(self).dispatch(action)
-      end
-      res.size == 1 ? res[0] : res
-    end
-    
-    private
-    
-    # This method is here to overwrite the one in the general_controller mixin
-    # The method ensures that when a url is generated with a hash, it contains a controller
-    def get_controller_for_url_generation(options)
-      controller = options[:controller] || params[:controller]
-      controller = params[:controller] if controller == :current
-      controller
-    end
-    
-  end  
-  
-end

data/lib/merb/cookies.rb

@@ -1,95 +0,0 @@
-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). 
-# 
-# == Writing 
-  # 
-  #   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 
-  # 
-  # == Reading 
-  # 
-  #   cookies[:user] # => "dave" 
-  #   cookies.size   # => 2 (the number of cookies) 
-  # 
-  # == Deleting 
-  # 
-  #   cookies.delete(:user) 
-  # 
-  # == Options 
-  # 
-  # * +value+   - the cookie's value 
-  # * +path+    - the path for which this cookie applies.  Defaults to the root 
-  #               of the application. 
-  # * +expires+ - the time at which this cookie expires, as a +Time+ object. 
-  class Cookies 
- 
-    def initialize(request_cookies, headers) 
-      @_cookies = request_cookies 
-      @_headers = headers 
-    end 
- 
-    # Returns the value of the cookie by +name+ or nil if no such cookie 
-    # exists. You set new cookies using cookies[]= 
-    def [](name) 
-      @_cookies[name] 
-    end 
- 
-    # Sets the value of a cookie. You can set the value directly or pass a hash 
-    # with options. 
-    # 
-    # == Example 
-    # 
-    #   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 
-    # 
-    # == Options 
-    # 
-    # * +value+   - the cookie's value or list of values (as an array). 
-    # * +path+    - the path for which this cookie applies.  Defaults to the root 
-    #               '/' of the application. 
-    # * +expires+ - the time at which this cookie expires, as a +Time+ object. 
-    def []=(name, options) 
-      value = '' 
-      if options.is_a?(Hash) 
-        options = Mash.new(options) 
-        value = Merb::Request.escape(options.delete(:value)) 
-      else 
-        value = Merb::Request.escape(options) 
-        options = Mash.new 
-      end 
-      @_cookies[name] = value 
-      set_cookie(name, value, options) 
-      Merb.logger.info("Cookie set: #{name} => #{value} -- #{options.inspect}") 
-      return 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. 
-    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}") 
-      return cookie 
-    end 
- 
-    private 
-      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_ext.rb

@@ -1,15 +0,0 @@
-corelib = File.dirname(__FILE__) + '/core_ext'
-
-%w[ inflector
-    class
-    kernel
-    object
-    mash
-    enumerable
-    module
-    string
-    hash
-    numeric
-    symbol
-    get_args
-  ].each {|fn| require File.join(corelib, fn)}

data/lib/merb/core_ext/class.rb

@@ -1,180 +0,0 @@
-# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
-# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
-# to, for example, an array without those additions being shared with either their parent, siblings, or
-# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
-class Class # :nodoc:
-  def cattr_reader(*syms)
-    syms.flatten.each do |sym|
-      next if sym.is_a?(Hash)
-      class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}
-          @@#{sym}
-        end
-
-        def #{sym}
-          @@#{sym}
-        end
-      EOS
-    end
-  end
-
-  def cattr_writer(*syms)
-    options = syms.last.is_a?(Hash) ? syms.pop : {}
-    syms.flatten.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-
-        #{"
-        def #{sym}=(obj)
-          @@#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    end
-  end
-
-  def cattr_accessor(*syms)
-    cattr_reader(*syms)
-    cattr_writer(*syms)
-  end
-  def class_inheritable_reader(*syms)
-    syms.each do |sym|
-      next if sym.is_a?(Hash)
-      class_eval <<-EOS
-        def self.#{sym}
-          read_inheritable_attribute(:#{sym})
-        end
-
-        def #{sym}
-          self.class.#{sym}
-        end
-      EOS
-    end
-  end
-
-  def class_inheritable_writer(*syms)
-    options = syms.last.is_a?(Hash) ? syms.pop : {}
-    syms.each do |sym|
-      class_eval <<-EOS
-        def self.#{sym}=(obj)
-          write_inheritable_attribute(:#{sym}, obj)
-        end
-
-        #{"
-        def #{sym}=(obj)
-          self.class.#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    end
-  end
-
-  def class_inheritable_array_writer(*syms)
-    options = syms.last.is_a?(Hash) ? syms.pop : {}
-    syms.each do |sym|
-      class_eval <<-EOS
-        def self.#{sym}=(obj)
-          write_inheritable_array(:#{sym}, obj)
-        end
-
-        #{"
-        def #{sym}=(obj)
-          self.class.#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    end
-  end
-
-  def class_inheritable_hash_writer(*syms)
-    options = syms.last.is_a?(Hash) ? syms.pop : {}
-    syms.each do |sym|
-      class_eval <<-EOS
-        def self.#{sym}=(obj)
-          write_inheritable_hash(:#{sym}, obj)
-        end
-
-        #{"
-        def #{sym}=(obj)
-          self.class.#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    end
-  end
-
-  def class_inheritable_accessor(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_writer(*syms)
-  end
-
-  def class_inheritable_array(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_array_writer(*syms)
-  end
-
-  def class_inheritable_hash(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_hash_writer(*syms)
-  end
-
-  def inheritable_attributes
-    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
-  end
-  
-  def write_inheritable_attribute(key, value)
-    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
-      @inheritable_attributes = {}
-    end
-    inheritable_attributes[key] = value
-  end
-  
-  def write_inheritable_array(key, elements)
-    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
-  end
-
-  def write_inheritable_hash(key, hash)
-    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
-  end
-
-  def read_inheritable_attribute(key)
-    inheritable_attributes[key]
-  end
-  
-  def reset_inheritable_attributes
-    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
-  end
-
-  private
-    # Prevent this constant from being created multiple times
-    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
-
-    def inherited_with_inheritable_attributes(child)
-      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
-      
-      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
-        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
-      else
-        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
-          memo.update(key => (value.dup rescue value))
-        end
-      end
-      
-      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
-    end
-
-    alias inherited_without_inheritable_attributes inherited
-    alias inherited inherited_with_inheritable_attributes
-end