Pistos-ramaze 2009.02 → 2009.04.08

data/lib/ramaze/helper/stack.rb

@@ -1,77 +1,75 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+  module Helper
 
-  # provides an call/answer mechanism, this is useful for example in a
-  # login-system.
-  #
-  # It is basically good to redirect temporarly somewhere else without
-  # forgetting where you come from and offering a nice way to get back
-  # to the last urls.
-  #
-  # Example:
-  #
-  # class AuthController < Controller
-  #   helper :stack
-  #
-  #   def login pass
-  #     if pass == 'password'
-  #       session[:logged_in] = true
-  #       answer '/'
-  #     else
-  #       "failed"
-  #     end
-  #   end
-  #
-  #   def logged_in?
-  #     !!session[:logged_in]
-  #   end
-  # end
-  #
-  # class ImportantController < Controller
-  #   helper :stack
-  #
-  #   def secret_information
-  #     call :login unless logged_in?
-  #     "Agent X is assigned to fight the RubyNinjas"
-  #   end
-  # end
-
-  module Helper::Stack
-    # redirect to another location and pushing the current location
-    # on the session[:STACK]
-
-    def push(frame)
-      (session[:STACK] ||= []) << frame
-    end
-
-    def call(this)
-      push request.fullpath
-      redirect this
-    end
-
-    # return to the last location on session[:STACK]
-    # The optional alternative paramter will be used to redirect in case you
-    # are not inside_stack?
-    # If the session has no stack and no alternative is given this won't do
-    # anything
+    # provides an call/answer mechanism, this is useful for example in a
+    # login-system.
+    #
+    # It is basically good to redirect temporarly somewhere else without
+    # forgetting where you come from and offering a nice way to get back
+    # to the last urls.
+    #
+    # Example:
+    #
+    # class AuthController < Controller
+    #   helper :stack
+    #
+    #   def login pass
+    #     if pass == 'password'
+    #       session[:logged_in] = true
+    #       answer '/'
+    #     else
+    #       "failed"
+    #     end
+    #   end
+    #
+    #   def logged_in?
+    #     !!session[:logged_in]
+    #   end
+    # end
+    #
+    # class ImportantController < Controller
+    #   helper :stack
+    #
+    #   def secret_information
+    #     call :login unless logged_in?
+    #     "Agent X is assigned to fight the RubyNinjas"
+    #   end
+    # end
+    module Stack
+      # redirect to another location and pushing the current location
+      # on the session[:STACK]
+      def push(frame)
+        (session[:STACK] ||= []) << frame
+      end
 
-    def answer(alternative = nil)
-      if inside_stack?
-        stack = session[:STACK]
-        target = stack.pop
-        session.delete(:STACK) if stack.empty?
-        redirect target
-      elsif alternative
-        redirect alternative
+      def call(this)
+        push(request.fullpath)
+        redirect(this)
       end
-    end
 
-    # check if the stack has something inside.
+      # return to the last location on session[:STACK]
+      # The optional alternative paramter will be used to redirect in case you
+      # are not inside_stack?
+      # If the session has no stack and no alternative is given this won't do
+      # anything
+      def answer(alternative = nil)
+        if inside_stack?
+          stack = session[:STACK]
+          target = stack.pop
+          session.delete(:STACK) if stack.empty?
+          redirect(target)
+        elsif alternative
+          redirect(alternative)
+        end
+      end
 
-    def inside_stack?
-      session[:STACK] and session[:STACK].any?
+      # check if the stack has something inside.
+      def inside_stack?
+        session[:STACK] and session[:STACK].any?
+      end
     end
   end
 end

data/lib/ramaze/helper/user.rb

@@ -4,42 +4,147 @@ module Ramaze
     # This helper provides a convenience wrapper for handling authentication
     # and persistence of users.
     #
-    # Example:
-    #
-    # class MainController < Ramaze::Controller
-    #   def index
-    #     if logged_in?
-    #       "Hello #{user.name}"
-    #     else
-    #       A('login', :href => Rs(:login))
+    # On every request, when you use the {User#user} method for the first time,
+    # we confirm the authentication and store the returned object in the
+    # request.env, usually this will involve a request to your database.
+    #
+    # @example Basic usage with User::authenticate
+    #
+    #   # We assume that User::[] will make a query and returns the requested
+    #   # User instance. This instance will be wrapped and cached.
+    #
+    #   class User
+    #     def self.authenticate(creds)
+    #       User[:name => creds['name'], :pass => creds['pass']]
     #     end
     #   end
     #
-    #   def login
-    #     user_login if request.post?
+    #   class Profiles < Ramaze::Controller
+    #     helper :user
+    #
+    #     def edit
+    #       redirect_referrer unless logged_in?
+    #       "Your profile is shown, your are logged in."
+    #     end
     #   end
-    # end
-
+    #
+    #   class Accounts < Ramaze::Controller
+    #     helper :user
+    #
+    #     def login
+    #       return unless request.post?
+    #       user_login(request.subset(:name, :pass))
+    #       redirect Profiles.r(:edit)
+    #     end
+    #
+    #     def logout
+    #       user_logout
+    #       redirect_referer
+    #     end
+    #   end
+    #
+    # On every request it checks authentication again and retrieves the model,
+    # we are not using a normal cache for this as it may lead to behaviour that
+    # is very hard to predict and debug.
+    #
+    # You can however, add your own caching quite easily.
+    #
+    # @example caching the authentication lookup with memcached
+    #
+    #   # Add the name of the cache you are going to use for the authentication
+    #   # and set all caches to use memcached
+    #
+    #   Ramaze::Cache.options do |cache|
+    #     cache.names = [:session, :user]
+    #     cache.default = Ramaze::Cache::MemCache
+    #   end
+    #
+    #   class User
+    #
+    #     # Try to fetch the user from the cache, if that fails make a query.
+    #     # We are using a ttl (time to live) of one hour, that's just to show
+    #     # you how to do it and not necessary.
+    #     def self.authenticate(credentials)
+    #       cache = Ramaze::Cache.user
+    #
+    #       if user = cache[credentials]
+    #         return user
+    #       elsif user = User[:name => creds['name'], :pass => creds['pass']]
+    #         cache.store(credentials, user, :ttl => 3600)
+    #       end
+    #     end
+    #   end
+    #
+    # @example Using a lambda instead of User::authenticate
+    #
+    #   # assumes all your controllers inhert from this one
+    #
+    #   class Controller < Ramaze::Controller
+    #     trait :user_callback => lambda{|creds|
+    #       User[:name => creds['name'], :pass => creds['pass']]
+    #     }
+    #   end
+    #
+    # @example Using a different model instead of User
+    #
+    #   # assumes all your controllers inhert from this one
+    #
+    #   class Controller < Ramaze::Controller
+    #     trait :user_model => Account
+    #   end
+    #
+    # @author manveru
+    # @todo convert the examples into real examples with specs
     module User
-      # return existing or instantiate User::Wrapper
+      # Using this as key in request.env
+      RAMAZE_HELPER_USER = 'ramaze.helper.user'.freeze
+
+      # Use this method in your application, but do not use it in conditionals
+      # as it will never be nil or false.
+      #
+      # @return [Ramaze::Helper::User::Wrapper] wrapped return value from model or callback
+      #
+      # @api external
+      # @author manveru
       def user
-        model = ancestral_trait[:user_model] ||= ::User
-        callback = ancestral_trait[:user_callback] ||= nil
-        STATE[:user] ||= Wrapper.new(model, callback)
-      end
+        env = request.env
+        found = env[RAMAZE_HELPER_USER]
+        return found if found
 
-      # shortcut for user.user_login but default argument are request.params
+        model, callback = ancestral_trait.values_at(:user_model, :user_callback)
+        model ||= ::User
+        env[RAMAZE_HELPER_USER] = Wrapper.new(model, callback)
+      end
 
+      # shortcut for user._login but default argument are request.params
+      #
+      # @param [Hash] creds the credentials that will be passed to callback or model
+      #
+      # @return [nil Hash] the given creds are returned on successful login
+      #
+      # @api external
+      # @see Ramaze::Helper::User::Wrapper#_login
+      # @author manveru
       def user_login(creds = request.params)
         user._login(creds)
       end
 
-      # shortcut for user.user_logout
-
+      # shortcut for user._logout
+      #
+      # @return [nil]
+      #
+      # @api external
+      # @see Ramaze::Helper::User::Wrapper#_logout
+      # @author manveru
       def user_logout
         user._logout
       end
 
+      # @return [true false] whether the user is logged in already.
+      #
+      # @api external
+      # @see Ramaze::Helper::User::Wrapper#_logged_in?
+      # @author manveru
       def logged_in?
         user._logged_in?
       end
@@ -50,7 +155,8 @@ module Ramaze
       #
       # In order to not interfere with the wrapped instance/model we start our
       # methods with an underscore.
-      # Suggestions on improvements as usual welcome.
+      #
+      # Patches and suggestions are highly appreciated.
       class Wrapper < BlankSlate
         attr_accessor :_model, :_callback, :_user
 
@@ -60,6 +166,11 @@ module Ramaze
           _login
         end
 
+        # @param [Hash] creds this hash will be stored in the session on successful login
+        # @return [Ramaze::Helper::User::Wrapper] wrapped return value from
+        #                                         model or callback
+        # @see Ramaze::Helper::User#user_login
+        # @autor manveru
         def _login(creds = _persistence)
           if @_user = _would_login?(creds)
             self._persistence = creds
@@ -82,11 +193,18 @@ module Ramaze
           end
         end
 
+        # @api internal
+        # @see Ramaze::Helper::User#user_logout
+        # @autor manveru
         def _logout
           _persistence.clear
-          STATE[:user] = nil
+          Current.request.env['ramaze.helper.user'] = nil
         end
 
+        # @return [true false] whether the current user is logged in.
+        # @api internal
+        # @see Ramaze::Helper::User#logged_in?
+        # @autor manveru
         def _logged_in?
           !!_user
         end
@@ -100,6 +218,7 @@ module Ramaze
         end
 
         # Refer everything not known
+        # THINK: This might be quite confusing... should we raise instead?
         def method_missing(meth, *args, &block)
           return unless _user
           _user.send(meth, *args, &block)

data/lib/ramaze/helper/xhtml.rb

@@ -1,23 +1,34 @@
-module Ramaze::Helper
-  module XHTML
-    def css(name, media = 'screen', options = {})
-      if options.empty?
-        "<link rel='stylesheet' href='/css/#{name}.css' type='text/css' media='#{media}' />"
-      elsif options[:only] == 'IE'
-        "<!--[if IE]>#{css(name, media)}<![endif]-->"
+module Ramaze
+  module Helper
+
+    # Provides shortcuts to the link/script tags.
+    module XHTML
+      LINK_TAG = '<link href=%p media=%p rel="stylesheet" type="text/css" />'
+      SCRIPT_TAG = '<script src=%p type="text/javascript"></script>'
+
+      def css(name, media = 'screen', options = {})
+        if options.empty?
+          LINK_TAG % ["/css/#{name}.css", media]
+        elsif options[:only].to_s.downcase == 'ie'
+          "<!--[if IE]>#{css(name, media)}<![endif]-->"
+        end
       end
-    end
 
-    def css_for(*names)
-      names.flatten.map{|name| css(name) }.join("\n")
-    end
+      def css_for(*args)
+        args.map{|arg| css(*arg) }.join("\n")
+      end
 
-    def js(name)
-      "<script src='/js/#{name}.js' type='text/javascript'></script>"
-    end
+      def js(name)
+        if name =~ /^http/ # consider it external full url
+          SCRIPT_TAG % name
+        else
+          SCRIPT_TAG % "/js/#{name}.js"
+        end
+      end
 
-    def js_for(*names)
-      names.flatten.map{|name| js(name) }.join("\n")
+      def js_for(*args)
+        args.map{|arg| js(*arg) }.join("\n")
+      end
     end
   end
 end

data/lib/ramaze/helper.rb

@@ -1,87 +1,12 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'ramaze/trinity'
+require 'innate/helper'
 
 module Ramaze
+  Helper = Innate::Helper
+  Innate::HelpersHelper.options.paths << File.dirname(__FILE__)
 
-  # A module used by the Templates and the Controllers
-  # it provides both Ramaze::Trinity (request/response/session)
-  # and also a helper method, look below for more information about it
-
-  module Helper
-    LOOKUP = Set.new
-    PATH = ['']
-    path = File.expand_path("#{BASEDIR}/../spec/ramaze/helper/")
-    trait :ignore => [
-      /#{Regexp.escape(path)}\//
-    ]
-
-    module Methods
-      def self.included other
-        other.send :extend, Trinity
-        other.send :extend, Methods
-        other.send :include, Trinity
-        super
-      end
-
-      def self.extend_object other
-        other.send :extend, Trinity
-        super
-      end
-
-      # 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, "helper #{name} not found"
-            end
-          end
-        end
-      end
-
-      private
-
-      # returns the Ramaze::Helper::Name Module Constant if exists.
-
-      def find_helper(name)
-        name = name.to_s.camel_case
-        ramaze_helper_consts = ::Ramaze::Helper.constants.grep(/^#{name}$/i)
-        if mod_name = ramaze_helper_consts.first
-          ::Ramaze::Helper.const_get(mod_name)
-        end
-      end
-
-      # Loads helper from /lib/ramaze/helper/name.(so, bundle, rb)
-      # raises LoadError if helper not found.
-
-      def require_helper(name)
-        paths = (PATH + [Global.root, "#{BASEDIR}/ramaze"]).join(',')
-        glob = "{#{paths}}/helper/#{name}.{so,bundle,rb}"
-        files = Dir[glob]
-        ignore = Helper.trait[:ignore]
-        files.reject!{|f| ignore.any?{|i| f =~ i }}
-        raise LoadError, "file for #{name} not found" unless file = files.first
-        require(file)
-      end
-
-      # injects the helper via include and extend, takes Constant as argument.
-
-      def use_helper(mod)
-        include mod
-        extend mod
-      end
-    end
-  end
+  require 'ramaze/helper/flash'
+  require 'ramaze/helper/link'
 end

data/lib/ramaze/log/analogger.rb

@@ -32,9 +32,8 @@ module Ramaze
       # integration to Logging
 
       def log(tag, *args)
-        log(tag, args.join("\n"))
+        super(tag, args.join("\n"))
       end
     end
-
   end
 end

data/lib/ramaze/log/informer.rb

@@ -9,6 +9,7 @@ module Ramaze
 
     class Informer
       include Logging
+      include Ramaze::Traited
 
       attr_accessor :out, :colorize, :log_levels
 

data/lib/ramaze/log/logging.rb

@@ -59,8 +59,8 @@ module Ramaze
 
     def error(ex)
       if ex.respond_to?(:exception)
-        message = [ex.backtrace].flatten[0..Global.backtrace_size]
-        message.map{|m| m.to_s.gsub(/^#{Regexp.escape(Dir.pwd)}/, '.') }
+        message = ex.backtrace
+        message.map!{|m| m.to_s.gsub(/^#{Regexp.escape(Dir.pwd)}/, '.') }
         message.unshift(ex.inspect)
       else
         message = ex.to_s
@@ -68,12 +68,6 @@ module Ramaze
       tag_log(:error, :to_s, *message)
     end
 
-    # raises
-
-    def log(*args)
-      raise "#log should be implemented by an instance including this module (#{self})"
-    end
-
     # nothing
 
     def shutdown

data/lib/ramaze/log/syslog.rb

@@ -1,4 +1,4 @@
-#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 #          Copyright (c) 2008 rob@rebeltechnologies.nl
 # All files in this distribution are subject to the terms of the Ruby license.
 
@@ -6,46 +6,46 @@ require 'syslog'
 
 # Add aliases for the levelnames used by Ramaze logging
 module Syslog
-  alias dev debug
-  alias warn warning
-  alias error err
-  module_function :dev, :warn, :error
+    alias dev debug
+    alias warn warning
+    alias error err
+    module_function :dev, :warn, :error 
 end
 
 module Ramaze
-  module Logger
-    # Logger class for writing to syslog. It is a *very* thin wrapper
-    # around the Syslog library.
-    class Syslog
-      include Logging
+    module Logger
+        # Logger class for writing to syslog. It is a *very* thin wrapper
+        # around the Syslog library.
+        class Syslog
+		    include Logging
 
-      # Open the syslog library, if it is allready open, we reopen it using the
-      # new argument list.  The argument list is passed on to the Syslog library
-      # so please check that, and man syslog for detailed information.
-      # There are 3 parameters:
-      #
-      #   ident:  The identification used in the log file, defaults to $0
-      #   options:  defaults to  Syslog::LOG_PID | Syslog::LOG_CONS
-      #   facility: defaults to Syslog::LOG_USER
-      #
-      def initialize( *args )
-        ::Syslog.close if ::Syslog.opened?
-        ::Syslog.open( *args )
-      end
+            # Open the syslog library, if it is allready open, we reopen it using the
+            # new argument list.  The argument list is passed on to the Syslog library
+            # so please check that, and man syslog for detailed information.  
+            # There are 3 parameters:
+            #
+            #   ident:  The identification used in the log file, defaults to $0
+            #   options:  defaults to  Syslog::LOG_PID | Syslog::LOG_CONS
+            #   facility: defaults to Syslog::LOG_USER
+            #
+            def initialize( *args )
+	    	    ::Syslog.close if ::Syslog.opened?
+	    	    ::Syslog.open( *args )
+            end
 
-      # just sends all messages received to ::Syslog
-      # We simply return if the log was closed for some reason, this behavior
-      # was copied from Informer.  We do not handle levels here. This will
-      # be done by te syslog daemon based on it's configuration.
-      def log(tag, *messages)
-        return if !::Syslog.opened?
-        ::Syslog.send(tag, *messages)
-      end
+            # just sends all messages received to ::Syslog
+            # We simply return if the log was closed for some reason, this behavior
+            # was copied from Informer.  We do not handle levels here. This will
+            # be done by te syslog daemon based on it's configuration.
+            def log(tag, *messages)
+			    return if !::Syslog.opened?
+              	::Syslog.send(tag, *messages)
+            end
 
-      # Has to call the modules singleton-method.
-      def inspect
-        ::Syslog.inspect
-      end
+            # Has to call the modules singleton-method.
+            def inspect
+              ::Syslog.inspect
+            end
+        end
     end
-  end
 end

data/lib/ramaze/log.rb

@@ -1,6 +1,18 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
+require 'ramaze/log/logging'
+
+module Ramaze
+  Log = Innate::Log
+
+  module Logger
+    autoload :Analogger, 'ramaze/log/analogger'
+  end
+end
+
+__END__
+
 require 'ramaze/log/logging'
 require 'ramaze/log/hub'
 require 'ramaze/log/informer'
@@ -14,12 +26,12 @@ rescue LoadError => ex
 end
 
 module Ramaze
-  autoload :Analogger, "ramaze/log/analogger.rb"
-  autoload :Knotify,   "ramaze/log/knotify.rb"
-  autoload :Syslog,    "ramaze/log/syslog.rb"
-  autoload :Growl,     "ramaze/log/growl.rb"
-  autoload :Xosd,      "ramaze/log/xosd.rb"
-  autoload :Logger,    "ramaze/log/logger.rb"
+  autoload :Analogger, "ramaze/log/analogger"
+  autoload :Knotify,   "ramaze/log/knotify"
+  autoload :Syslog,    "ramaze/log/syslog"
+  autoload :Growl,     "ramaze/log/growl"
+  autoload :Xosd,      "ramaze/log/xosd"
+  autoload :Logger,    "ramaze/log/logger"
 
   unless defined?(Log)
     Log = Logger::LogHub.new(Logger::Informer)