merb 0.3.7 → 0.4.0

data/lib/merb/caching/fragment_cache.rb

@@ -6,11 +6,16 @@ module Merb
           @cache ||= determine_cache_store
         end
         
+        def clear
+          cache.clear
+          @cache = nil
+        end
+        
         def get(name)
           cache.get(name)
         end
         
-        def put(name, content = nil)
+        def put(name, content = nil)          
           cache.put(name, content)
           content
         end
@@ -20,12 +25,12 @@ module Merb
         end
         
         def determine_cache_store
-          if ::Merb::Server.cache_store.to_s == "file"
+          if ::Merb::Server.config[:cache_store].to_s == "file"
             require 'merb/caching/store/file_cache'
             ::Merb::Caching::Store::FileCache.new
           else
-            require 'merb/caching/store/memory_cache'            
-            ::Merb::Caching::Store::MemoryCache.new            
+            require 'merb/caching/store/memory_cache'
+            ::Merb::Caching::Store::MemoryCache.new
           end
         end  
       end

data/lib/merb/caching/store/file_cache.rb

@@ -10,29 +10,31 @@ module Merb
             
         def initialize(name = "cache", keepalive = nil)
           @path = File.join(MERB_ROOT, name)
-          @keepalive = keepalive
-      
-          FileUtils.mkdir_p(@path, :mode => 0700)
+          @keepalive = keepalive  
         end
       
-        def []=(k,v)
-          fn = File.join(@path, escape_filename(k.to_s) )
-          encode_file(fn, v)
+        def []=(key,val)
+          key = escape_filenames([key].flatten)
+          FileUtils.mkdir_p(File.join(@path, *key[0..-2]), :mode => 0700)
+          fn = File.join(@path, *key )
+          encode_file(fn, val)
         end
         alias :put :[]=
         alias :write :[]=
         
-        def [](k)
-          fn = File.join(@path, escape_filename(k.to_s) )
+        def [](key)          
+          key = escape_filenames([key].flatten)          
+          fn = File.join(@path, *key )
           return nil unless File.exists?(fn)
           decode_file(fn)
         end
         alias :get :[]
         alias_method :read, :[]
       
-        def delete(k)
-          f = File.join(@path, escape_filename(k.to_s))
-          File.delete(f) if File.exists?(f)
+        def delete(key)          
+          key = escape_filenames([key].flatten)
+          f = File.join(@path, *key)
+          FileUtils.rm_rf(f) 
         end
         
         def gc!
@@ -44,12 +46,16 @@ module Merb
             File.delete(fn) if now > expire_time
           end
         end
+        
+        def clear
+          all.each{|file| delete(File.basename(file)) }
+        end
 
         private
       
         def decode_file(fn)
           val = nil
-          File.open(fn,"rb") do |f|
+          File.open(fn,"r+b") do |f|
             f.flock(File::LOCK_EX)
             val = Marshal.load( f.read )
             f.flock(File::LOCK_UN)
@@ -70,8 +76,10 @@ module Merb
           Dir.glob( File.join(@path, '*' ) )
         end
         # need this for fat filesystems
-        def escape_filename(fn)
-          URI.escape(fn, /["\/:;|=,\[\]]/)
+        def escape_filenames(fns)
+          fns.collect do |fn|
+            URI.escape(fn.to_s, /["\/:;|=,\[\]]/)            
+          end
         end
       
       end

data/lib/merb/caching/store/memory_cache.rb

@@ -13,26 +13,41 @@ module Merb
         end
         
         def [](key)
+          key = [key].flatten.collect{|k| k.to_s}
           @mutex.synchronize {
             @timestamps[key] = Time.now
-            @cache[key]
+            sub_cache = @cache
+            key[0..-2].each do |subkey|
+              sub_cache = (sub_cache[subkey] ||= {})
+            end
+            sub_cache[key[-1]]
           }
         end
         alias_method :get, :[]
         alias_method :read, :[]
          
-        def []=(key, val) 
+        def []=(key, val)     
+          key = [key].flatten.collect{|k| k.to_s}
           @mutex.synchronize {
+            sub_cache = @cache
+            key[0..-2].each do |subkey|
+              sub_cache = (sub_cache[subkey] ||= {})
+            end
+            sub_cache[key[-1]] = val
             @timestamps[key] = Time.now
-            @cache[key] = val
           } 
         end
         alias_method :put, :[]=
         alias_method :write, :[]=
         
         def delete(key)
+          key = [key].flatten.collect{|k| k.to_s}
           @mutex.synchronize {
-            @cache.delete(key)
+            sub_cache = @cache
+            key[0..-2].each do |subkey|
+              sub_cache = (sub_cache[subkey] ||= {})
+            end
+            sub_cache.delete(key[-1])
           }
         end
         alias_method :remove, :delete
@@ -57,11 +72,14 @@ module Merb
         def keys
           @cache.keys 
         end  
+        
+        def clear
+          @cache = Hash.new
+          @timestamps = Hash.new
+          @mutex = Mutex.new          
+        end
               
       end 
-    
     end
-  
-  end    
-  
+  end   
 end  

data/lib/merb/{merb_constants.rb → constants.rb}

@@ -15,6 +15,7 @@ module Merb
     }.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
@@ -27,7 +28,8 @@ module Merb
     APPLICATION_JSON       = 'application/json'.freeze 
     TEXT_JSON              = 'text/x-json'.freeze
     APPLICATION_XML        = 'application/xml'.freeze 
-    TEXT_XML               = 'text/xml'.freeze  
+    TEXT_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
@@ -40,11 +42,11 @@ module Merb
     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
+    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

@@ -0,0 +1,178 @@
+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.
+  class Controller < AbstractController
+    cattr_accessor :_subclasses
+    self._subclasses = []
+    
+    class_inheritable_accessor :_session_id_key, :_session_expiry
+    self._session_id_key = :_session_id
+    self._session_expiry = Time.now + Merb::Const::WEEK * 2
+
+    include Merb::ControllerMixin
+    include Merb::ResponderMixin
+    include Merb::ControllerExceptions
+    
+    class << self
+      def inherited(klass)
+        _subclasses << 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::Server.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::Server.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
+      request.cookies
+    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
+    
+  end  
+  
+end

data/lib/merb/core_ext.rb

@@ -1,13 +1,15 @@
-corelib = __DIR__+'/merb/core_ext'
+corelib = File.dirname(__FILE__) + '/core_ext'
 
-%w[ merb_inflector
-    merb_class
-    merb_kernel
-    merb_object
-    merb_enumerable
-    merb_module
-    merb_string
-    merb_hash
-    merb_numeric
-    merb_symbol
+%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/get_args.rb

@@ -0,0 +1,52 @@
+begin
+  require 'ruby2ruby'
+
+  class ParseTreeArray < Array
+    def self.translate(*args)
+      self.new(ParseTree.translate(*args))
+    end
+  
+    def deep_array_node(type = nil)
+      each do |node|
+        return ParseTreeArray.new(node) if node.is_a?(Array) && (!type || node[0] == type)
+        next unless node.is_a?(Array)
+        return ParseTreeArray.new(node).deep_array_node(type)
+      end
+      nil
+    end
+  
+    def arg_nodes
+      self[1..-1].inject([]) do |sum,item|
+        sum << [item] unless item.is_a?(Array)
+        sum
+      end
+    end
+    
+    def get_args
+      arg_node = deep_array_node(:args)
+      args = arg_node.arg_nodes
+      lasgns = arg_node.deep_array_node(:block)[1..-1]
+      lasgns.each do |asgn|
+        args.assoc(asgn[1]) << eval(RubyToRuby.new.process(asgn[2]))
+      end
+      args
+    end
+  
+  end
+
+  module GetArgs
+    def get_args
+      klass, meth = self.to_s.split(/ /).to_a[1][0..-2].split("#")
+      ParseTreeArray.translate(Object.const_get(klass), meth).get_args
+    end
+  end
+
+  class UnboundMethod
+    include GetArgs
+  end
+
+  class Method
+    include GetArgs
+  end
+rescue LoadError
+end