ramaze 0.3.5 → 0.3.9

data/lib/ramaze/current/session/hash.rb

@@ -0,0 +1,65 @@
+module Ramaze
+  class Session
+
+    # The Session::Hash acts as the wrapper for a simple Hash
+    #
+    # Its purpose is to notify the underlying cache, in which the sessions
+    # are stored, about updates.
+    class Hash
+
+      # Sets @hash to an empty Hash
+
+      def initialize
+        @hash = {}
+      end
+
+      # relays all the methods to the @hash and updates the session_cache in
+      # Session.current.sessions if anything changes.
+
+      def method_missing(*args, &block)
+        old = @hash.dup
+        result = @hash.send(*args, &block)
+        unless old == @hash
+          Cache.sessions[Current.session.session_id] = self
+        end
+        result
+      end
+
+      # Calls #inspect on the wrapped @hash
+
+      def inspect
+        @hash.inspect
+      end
+
+      # Use client side session variables
+
+      def client
+        Request.current['session.client'] ||= unmarshal(Request.current.cookies["#{Session::SESSION_KEY}-client"]) || {}
+      end
+
+      private
+
+      # Marshal a session hash into safe cookie data. Include an integrity hash.
+      def marshal(session)
+        data = [ Marshal.dump(session) ].pack('m').chop
+        "#{data}--#{generate_digest(data)}"
+      end
+
+      # Unmarshal cookie data to a hash and verify its integrity.
+      def unmarshal(cookie)
+        if cookie
+          data, digest = cookie.split('--')
+          return nil unless digest == generate_digest(data)
+          Marshal.load(data.unpack('m').first)
+        end
+      end
+
+      # Generate the inline SHA512 message digest. Larger (128 bytes) than SHA256
+      # (64 bytes) or RMD160 (40 bytes), but small relative to the 4096 byte
+      # max cookie size.
+      def generate_digest(data)
+        Digest::SHA512.hexdigest "#{data}#{Session.trait[:secret]}"
+      end
+    end
+  end
+end

data/lib/ramaze/dispatcher.rb

@@ -1,10 +1,7 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'timeout'
-
 require 'ramaze/error'
-require 'ramaze/adapter'
 require 'ramaze/tool/mime'
 
 require 'ramaze/dispatcher/action'
@@ -31,9 +28,7 @@ module Ramaze
       # Entry point for Adapter#respond, takes a Rack::Request and
       # Rack::Response, sets up the environment and the goes on to dispatch
       # for the given path from rack_request.
-      def handle rack_request, rack_response
-        setup_environment(rack_request, rack_response)
-
+      def handle
         path = request.path_info.squeeze('/')
 
         case path
@@ -124,28 +119,6 @@ module Ramaze
         }
         Dispatcher::Error.process(result, meta)
       end
-
-      # finalizes the session and assigns the key to the response via
-      # set_cookie.
-
-      def set_cookie
-        session.finalize
-        hash = {:value => session.session_id}.merge(Session::COOKIE)
-        response.set_cookie(Session::SESSION_KEY, hash)
-      end
-
-      # Setup the Trinity (Request, Response, Session) and store them as
-      # thread-variables in Thread.current
-      #   Thread.current[:request]  == Request.current
-      #   Thread.current[:response] == Response.current
-      #   Thread.current[:session]  == Session.current
-
-      def setup_environment rack_request, rack_response
-        this = Thread.current
-        this[:request]  = rack_request
-        this[:session]  = Session.new(request) if Global.sessions
-        this[:response] = rack_response
-      end
     end
   end
 end

data/lib/ramaze/dispatcher/action.rb

@@ -23,9 +23,12 @@ module Ramaze
         # post-processing.
 
         def process(path)
-          Inform.info("Dynamic request from #{request.ip}: #{request.request_uri}")
-          body = Controller.handle(path)
-          response = Response.current.build(body)
+          Log.info("Dynamic request from #{request.ip}: #{request.request_uri}")
+
+          catch(:respond) {
+            body = Controller.handle(path)
+            response = Response.current.build(body)
+          }
           FILTER.inject(response){|r,f| f.call(r) }
         rescue Ramaze::Error => ex
           ex

data/lib/ramaze/dispatcher/directory.rb

@@ -26,7 +26,7 @@ module Ramaze
           dir = ::File.expand_path(Global.public_root/::File.expand_path(path, '/'))
 
           if ::File.directory?(dir)
-            Inform.debug("Serving directory listing: #{dir}")
+            Log.debug("Serving directory listing: #{dir}")
 
             status = Ramaze::STATUS_CODE['OK']
             header = {'Content-Type' => "text/html"}

data/lib/ramaze/dispatcher/error.rb

@@ -44,7 +44,7 @@ module Ramaze
             action_response = Dispatcher::Action.process(newpath)
             case action_response
             when Ramaze::Error
-              Inform.debug("No custom error page found on #{controller}, going to #{path}")
+              Log.debug("No custom error page found on #{controller}, going to #{path}")
             else
               action_response.status = status
               return action_response
@@ -58,8 +58,29 @@ module Ramaze
             response.build(error.message, status)
           end
         rescue Object => ex
-          Inform.error(ex)
-          response.build(ex.message, status)
+          Log.error(ex)
+          begin
+            m = ex.message
+            c = ex.class
+            b = (ex.backtrace || []).join("\n")
+            body = <<-html
+            ==== Error ====\n
+              #{ m } (#{ c })
+              #{ b }\n
+            ==== Request ====\n
+              #{ Request.current.pretty }\n
+            ==== Request ====\n
+              #{ Response.current.pretty }\n
+            ==== Session ====\n
+              #{ Session.current.pretty }\n
+            ==== Global ====\n
+              #{ Global.pretty }\n
+            html
+            response['Content-Type'] = 'text/plain'
+            response.build(body.unindent, status)
+          rescue Object
+            raise
+          end
         end
 
         # Only logs new errors with full backtrace, repeated errors are shown
@@ -68,10 +89,10 @@ module Ramaze
           error_message = error.message
 
           if trait[:last_error] == error_message or error.is_a? Ramaze::Error::NoAction
-            Inform.error(error_message)
+            Log.error(error_message)
           else
             trait[:last_error] = error_message
-            Inform.error(error)
+            Log.error(error)
           end
         end
 

data/lib/ramaze/dispatcher/file.rb

@@ -22,7 +22,7 @@ module Ramaze
         # searches for the file and builds a response with status 200 if found.
 
         def process(path)
-          return unless file = open_file(path)
+          return unless file = open_file(CGI.unescape(path))
           if file == :NotModified
             return response.build([], STATUS_CODE['Not Modified'])
           end
@@ -36,6 +36,7 @@ module Ramaze
           file = resolve_path(path)
 
           if ::File.file?(file) or ::File.file?(file=file/'index')
+            return unless in_public?(file)
             response['Content-Type'] = Tool::MIME.type_for(file) unless ::File.extname(file).empty?
             mtime = ::File.mtime(file)
             response['Last-Modified'] = mtime.httpdate
@@ -63,11 +64,21 @@ module Ramaze
           end
         end
 
+        def in_public?(path)
+          expand(path).start_with?(expand(Global.public_root))
+        end
+
+        private
+
+        def expand(path)
+          ::File.expand_path(path)
+        end
+
         def log(file)
           case file
           when *Global.boring
           else
-            Inform.debug("Serving static: #{file}")
+            Log.debug("Serving static: #{file}")
           end
         end
       end

data/lib/ramaze/gestalt.rb

@@ -117,7 +117,9 @@ module Ramaze
         gsub(/>/, '>')
     end
 
-    # @out.to_s
+    def tag(name, *args, &block)
+      _gestalt_call_tag(name.to_s, args, &block)
+    end
 
     def to_s
       @out.to_s

data/lib/ramaze/global.rb

@@ -1,9 +1,6 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'ostruct'
-require 'set'
-
 require 'ramaze/global/dsl'
 
 module Ramaze
@@ -70,6 +67,9 @@ module Ramaze
     o "All paths to controllers are mapped here.",
       :mapping => {}
 
+    o "For your own modes to decide on",
+      :mode => :live, :cli => [:live, :dev]
+
     o "The place ramaze was started from, useful mostly for debugging",
       :origin => :main
 
@@ -108,6 +108,9 @@ module Ramaze
 
     o "Enable directory listing",
       :list_directories => false, :cli => false
+
+    o "Disable templates without actions",
+      :actionless_templates => true, :cli => true
   end
 
   require 'ramaze/global/globalstruct'

data/lib/ramaze/global/globalstruct.rb

@@ -19,7 +19,9 @@ module Ramaze
     ADAPTER_ALIAS = {
       :cgi                 => :Cgi,
       :fcgi                => :Fcgi,
+      :scgi                => :Scgi,
       :thin                => :Thin,
+      :ebb                 => :Ebb,
       :lsws                => :Lsws,
       :webrick             => :WEBrick,
       :mongrel             => :Mongrel,
@@ -134,7 +136,7 @@ module Ramaze
 
     # Creates a new attr_accessor like method-pair.
     def create_member key, value = nil
-      Inform.warn "Create #{key}=#{value.inspect} on Global"
+      Log.warn "Create #{key}=#{value.inspect} on Global"
 
       @table ||= {}
       key = key.to_sym

data/lib/ramaze/helper.rb

@@ -10,28 +10,74 @@ module Ramaze
   # and also a helper method, look below for more information about it
 
   module Helper
-    include Trinity
-
-    private
-
-    # This loads the helper-files from /ramaze/helper/helpername.rb and
-    # includes it into Ramaze::Template (or wherever it is called)
-    #
-    # Usage:
-    #   helper :redirect, :link
-
-    def helper *syms
-      syms.each do |sym|
-        mod_name = sym.to_s.capitalize + 'Helper'
-        begin
-          include ::Ramaze.const_get(mod_name)
-          extend ::Ramaze.const_get(mod_name)
-        rescue NameError
-          files = Dir["{helper,#{BASEDIR/:ramaze/:helper}}/#{sym}.{rb,so}"]
-          raise LoadError, "#{mod_name} not found" unless files.any?
-          require(files.first) ? retry : raise
+    LOOKUP = Set.new
+    trait :ignore => [
+      /#{Regexp.escape(File.expand_path(BASEDIR/'../spec/ramaze/helper/'))}\//
+    ]
+
+    module Methods
+      private
+
+      # This loads the helper-files from /ramaze/helper/helpername.rb and
+      # includes it into Ramaze::Template (or wherever it is called)
+      #
+      # Usage:
+      #   helper :redirect, :link
+
+      def helper(*syms)
+        syms.each do |sym|
+          name = sym.to_s
+          if mod = find_helper(name)
+            use_helper(mod)
+          else
+            if require_helper(name)
+              redo
+            else
+              raise LoadError, "#{name} not found"
+            end
+          end
         end
       end
+
+      # Will be going to be much simpler after deprecation *sigh*
+      def find_helper(name)
+        ramaze_helper_consts = ::Ramaze::Helper.constants.grep(/^#{name}$/i)
+        ramaze_consts = ::Ramaze.constants.grep(/^#{name}Helper$/i)
+        if mod_name = ramaze_helper_consts.first
+          ::Ramaze::Helper.const_get(mod_name)
+        elsif mod_name = ramaze_consts.first
+          mod = ::Ramaze.const_get(mod_name)
+          new_name = "Ramaze::Helper::" << mod_name.split('::').last[/^(.*)Helper$/, 1]
+          Log.warn "#{mod_name} is being deprecated, use #{new_name} instead"
+          mod
+        end
+      end
+
+      def require_helper(name)
+        glob = "{,#{APPDIR},#{BASEDIR/:ramaze}}/helper/#{name}.{so,bundle,rb}"
+        files = Dir[glob]
+        ignore = Helper.trait[:ignore]
+        files.reject!{|f| ignore.any?{|i| f =~ i }}
+        raise LoadError, "#{name} not found" unless file = files.first
+        require(file)
+      end
+
+      def use_helper(mod)
+        include mod
+        extend mod
+      end
+
+      def Methods.included other
+        other.send :extend, Trinity
+        other.send :include, Trinity
+        other.send :extend, Methods
+        super
+      end
+
+      def Methods.extend_object other
+        other.send :extend, Trinity
+        super
+      end
     end
   end
 end

data/lib/ramaze/helper/aspect.rb

@@ -16,56 +16,64 @@ module Ramaze
   #
   #   helper :aspect
 
-  module AspectHelper
+  module Helper::Aspect
 
-    # Define traits on class this module is included into.
+    private
 
-    def self.included(klass)
-      klass.trait[:aspects] ||= { :before => {}, :after => {} }
+    # lazily and smartly inherit copy of aspects trait from parent, or
+    # bootstrap our own 
+    def aspects
+      trait[:aspects] ||= (
+        if hash = ancestral_trait[:aspects]
+          { :before => hash[:before].dup, :after => hash[:after].dup }
+        else
+          { :before => {}, :after => {} }
+        end
+      )
     end
 
-    private
-
-    # run block before given actions.
+    # run block before given actions or, if no actions specified, all actions.
     def before(*meths, &block)
-      aspects = trait[:aspects][:before]
+      return before_all(*meths, &block) if meths.empty?
       meths.each do |meth|
-        aspects[meth.to_s] = block
+        aspects[:before][meth.to_s] = block
       end
     end
     alias pre before
 
     # Run block before all actions.
     def before_all(&block)
-      trait[:aspects][:before][:all] = block
+      aspects[:before][:all] = block
     end
     alias pre_all before_all
 
-    # run block after given actions.
+    # run block after given actions or, if no actions specified, all actions.
     def after(*meths, &block)
-      aspects = trait[:aspects][:after]
+      return after_all(*meths, &block) if meths.empty?
       meths.each do |meth|
-        aspects[meth.to_s] = block
+        aspects[:after][meth.to_s] = block
       end
     end
     alias post after
 
     # Run block after all actions.
     def after_all(&block)
-      trait[:aspects][:after][:all] = block
+      aspects[:after][:all] = block
     end
     alias post_all after_all
 
-    # run block before and after given actions.
+    # run block before and after given actions, or, if no actions specified.
+    # all actions
     def wrap(*meths, &block)
+      return wrap_all(*meths, &block) if meths.empty?
       before(*meths, &block)
       after(*meths, &block)
     end
 
     # run block before and after all actions.
     def wrap_all(&block)
-      trait[:aspects][:before][:all] = block
-      trait[:aspects][:after][:all] = block
+      aspects[:before][:all] = block
+      aspects[:after][:all] = block
     end
   end