ramaze 0.0.7 → 0.0.8

data/lib/ramaze/helper/auth.rb

@@ -13,10 +13,11 @@ module Ramaze
   # implement your own authentication.
 
   module AuthHelper
+
+    # add AspectHelper and StackHelper on inclusion of AuthHelper
+
     def self.included(klass)
-      klass.class_eval do
-        helper :aspect, :stack
-      end
+      klass.send(:helper, :aspect, :stack)
     end
 
     # The default Element to use (if any)
@@ -28,12 +29,17 @@ module Ramaze
     # if no password given, shows a simple form to input it.
 
     def login
-      if check_auth(request['username'], request['password'])
+      username, password = request.params.values_at('username', 'password')
+      if check_auth(username, password)
         session[:logged_in] = true
         inside_stack? ? answer : redirect( R(self) )
       else
+        if AUTH_ELEMENT and AUTH_ELEMENT.to_s.split.any?
+          open_element = "<#{AUTH_ELEMENT}>"
+          close_element = "</#{AUTH_ELEMENT}>"
+        end
         %{
-          <#{AUTH_ELEMENT}>
+          #{open_element}
             <form method="POST" action="#{R(self, :login)}"
               <ul style="list-style:none;">
                 <li>Username: <input type="text" name="username" /></li>
@@ -41,7 +47,7 @@ module Ramaze
                 <li><input type="submit" /></li>
               </ul>
             </form>
-          </#{AUTH_ELEMENT}>
+          #{close_element}
         }
       end
     end
@@ -75,7 +81,7 @@ module Ramaze
     # Hash.
     # If it is neither of the above it has at least to respond to #[]
     # which will pass it the username as key and it should answer with the
-    # password as a SHA1.hexdigest.
+    # password as a Digest::SHA1.hexdigest.
     #
     # The method and Proc are both called on demand.
     #
@@ -97,12 +103,13 @@ module Ramaze
     #   trait :auth_tagle => 'auth_table'
     #
     #   # Lambda that will be called upon demand
-    #   trait :auth_table => lambda{ {'manveru' => SHA1.hexdigest 'password'} }
+    #   trait :auth_table => lambda{ {'manveru' => Digest::SHA1.hexdigest 'password'} }
     #
     #   # Hash holding the data.
-    #   trait :auth_table => {'manveru' => SHA1.hexdigest('password')}
+    #   trait :auth_table => {'manveru' => Digest::SHA1.hexdigest('password')}
 
     def check_auth user, pass
+      return false if (not user or user.empty?) and (not pass or pass.empty?)
       auth_table = ancestral_trait[:auth_table] ||= {}
 
       auth_table = method(auth_table) if auth_table.is_a?(Symbol)

data/lib/ramaze/helper/cache.rb

@@ -1,52 +1,57 @@
 #          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
+
 module Ramaze
   module CacheHelper
-    private
 
-    # a simple cache for values based on Global.cache
+    # Cache for single key/value pairs
 
-    def value_cache
-      @@cache ||= Global.cache.new
-    end
+    trait :value_cache  => Global.cache.new
 
-    # forget about one cached action
+    # Cache for values returned from actions
 
-    def uncache action
-      Global.cached_actions[self.class].each do |e|
-        e.include?(action.to_s)
-      end
-    end
-
-    # uncache all actions
+    trait :action_cache => Global.cache.new
 
-    def uncache_all
-      Global.cached_actions.delete(self.class)
-    end
-    alias uncache_all_actions uncache_all
+    private
 
-    # cache all given methods
+    # use this to cache values in your controller and templates,
+    # for example heavy calculations or time-consuming queries.
 
-    def cache(*actions)
-      self.class.cache(*actions)
+    def value_cache
+      ancestral_trait[:value_cache]
     end
-    alias cache_actions cache
-
-    # define the cache class-method on inclusion
 
-    def self.included(klass)
-      klass.class_eval do
-        class << self
-
-          # mark actions for caching
-
-          def cache(*actions)
-            Global.cache_actions[self].merge(*actions.flatten.map{|a| a.to_s })
-          end
-          alias cache_actions cache
+    # holds the values returned on the first call to a cached action.
+    # To uncache, simply delete.
+    #
+    # Please note that the action is cached by a combination of
+    # [action, parameter].inspect - so it is a bit awkward to use.
+    #
+    # Suggestions welcome.
+    #
+    # Example:
+    #
+    #   action_cache.delete '["index", []]'
+    #
+    # or by delete_if
+    #
+    #   action_cache.delete_if{|key, value| key =~ /"index",/}
+
+    def action_cache
+      ancestral_trait[:action_cache]
+    end
 
-        end
-      end
+    # This refers to the class-trait of cached actions, you can
+    # add/remove actions to be cached.
+    #
+    # Example:
+    #
+    #   class FooController < Ramaze::Controller
+    #     trait :actions_cached => [:index, :map_of_the_internet]
+    #   end
+
+    def actions_cached
+      ancestral_trait[:actions_cached]
     end
   end
 end

data/lib/ramaze/helper/feed.rb

@@ -129,7 +129,7 @@ module ReFeed
     unless attributes or attributes.empty?
       "<#{name}>#{xml}</#{name}>"
     else
-      "<#{name} #{attributes.join(' ')}><#{xml}></#{name}>"
+      "<#{name} #{attributes.join(' ')}>#{xml}</#{name}>"
     end
   end
 end

data/lib/ramaze/helper/flash.rb

@@ -0,0 +1,34 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # The purpose of this class is to provide an easy way of setting/retrieving
+  # from the current flash.
+  #
+  # Flash is a way to keep a temporary pairs of keys and values for the duration
+  # of two requests, the current and following.
+  #
+  # Very vague Example:
+  #
+  # On the first request, for example on registering:
+  #
+  #   flash[:error] = "You should reconsider your username, it's taken already"
+  #   redirect R(self, :register)
+  #
+  # This is the request from the redirect:
+  #
+  #   do_stuff if flash[:error]
+  #
+  # On the request after this, flash[:error] is gone.
+
+  module FlashHelper
+    private
+
+    # answers with Session.current.flash
+
+    def flash
+      Session.current.flash
+    end
+  end
+end

data/lib/ramaze/helper/link.rb

@@ -2,7 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  # LinkHelper is included into the Template::Ramaze by default
+  # LinkHelper is included into the Controller by default
   #
   # this helper tries to get along without any major magic, the only 'magic'
   # thing is that it looks up controller-paths if you pass it a controller
@@ -51,6 +51,7 @@ module Ramaze
       end
 
       raw, title = hash.delete(:raw), hash.delete(:title)
+      params = {:class => hash.delete(:class), :id => hash.delete(:id)}
       opts = hash.inject('?'){|s,(k,v)| s << "#{k}=#{v};"}[0..-2]
       link = to.join('/').squeeze('/') << (opts.empty? ? '' : opts)
 
@@ -58,7 +59,8 @@ module Ramaze
         link
       else
         title ||= link.split('/').last.to_s.split('?').first || 'index'
-        %{<a href="#{link}">#{title}</a>}
+        params = params.inject(''){|s,(k,v)| s + (k and v ? %{ #{k}="#{v}"} : '')}
+        l = %{<a href="#{link}"#{params}>#{title}</a>}
       end
     end
 
@@ -76,5 +78,9 @@ module Ramaze
 
       link(*to)
     end
+
+    def Rs(*to)
+      R(self, *to)
+    end
   end
 end

data/lib/ramaze/helper/openid.rb

@@ -0,0 +1,63 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'tmpdir'
+
+require 'openid'
+
+module Ramaze
+  module OpenidHelper
+    def openid_login_form
+      %{
+<form method="GET" action="#{R(self, :openid_begin)}">
+  Identity URL: <input type="text" name="url" />
+  <input type="submit" />
+</form>
+      }
+    end
+
+    def openid_begin
+      url = request['url']
+      redirect_referrer if url.nil? or url.empty?
+      session[:openid_entry] = referrer
+
+      openid_request = openid_consumer.begin(url)
+      case openid_request.status
+      when OpenID::FAILURE
+        flash[:error] = "OpenID - Unable to find openid server for `#{url}'"
+
+        redirect_referrer
+      when OpenID::SUCCESS
+        host, port   = Ramaze::Global.host, Ramaze::Global.port
+        root         = "http://#{host}:#{port}/"
+        return_to    = root[0..-2] + R(self, :openid_complete)
+        redirect_url = openid_request.redirect_url(root, return_to)
+
+        redirect(redirect_url)
+      end
+    end
+
+    def openid_complete
+      openid_response = openid_consumer.complete(request.params)
+
+      case openid_response.status
+      when OpenID::FAILURE
+        flash[:error] = 'OpenID - Verification failed.'
+      when OpenID::SUCCESS
+        flash[:success] = 'OpenID - Verification done.'
+      end
+
+      redirect session[:openid_entry]
+    end
+
+    private
+
+    def openid_consumer
+      OpenID::Consumer.new(session, Ramaze::Global.openid_store)
+    end
+  end
+end
+
+openid_store_file = File.join(Dir.tmpdir, 'openid-store')
+
+Global.openid_store ||= OpenID::FilesystemStore.new(openid_store_file)

data/lib/ramaze/helper/redirect.rb

@@ -6,37 +6,38 @@ module Ramaze
   # RedirectHelper actually takes advantage of LinkHelper.link_raw to build the links
   # it redirects to.
   # It doesn't do much else than this:
-  #     setting a status-code of 303 and a head['Location'] = link
+  #     setting a status-code of 303 and a response['Location'] = link
   # returning some nice text for visitors who insist on ignoring those hints :P
   #
   # example of usage:
   #   redirect MainController
   #   redirect MainController, :foo
   #   redirect 'foo/bar'
+  #   redirect :index, :status => 309
   #
   # TODO:
-  #   - setting custom status-code, it ignores any preset ones at the moment
   #   - maybe some more options, like a delay
   #
 
   module RedirectHelper
 
     # Usage:
-    #   redirect MainController
-    #   redirect MainController, :foo
+    #   redirect R(MainController)
+    #   redirect R(MainController, :foo)
     #   redirect 'foo/bar'
 
-    def redirect *target
-      target = target.join('/')
+    def redirect target, opts = {}
+      target = target.to_s
+      head = {
+        'Location' => target
+      }.merge(response.header)
 
-      response.head['Location'] = target
+      status = opts[:status] || STATUS_CODE[:see_other]
 
-      hash = target.find{|h| h.is_a?(Hash)} and status = hash.delete(:status) rescue nil
+      body = %{Please follow <a href="#{target}">#{target}</a>!}
 
-      response.code = status || STATUS_CODE[:see_other]
-      response.out = %{Please follow <a href="#{target}">#{target}</a>!}
 
-      throw :respond
+      throw(:redirect, :body => body, :status => status, :head => head)
     end
 
     # redirect to the location the browser says it's coming from.

data/lib/ramaze/helper/stack.rb

@@ -12,7 +12,7 @@ module Ramaze
   #
   # Example:
   #
-  # class AuthController < Template::Ramaze
+  # class AuthController < Controller
   #   helper :stack
   #
   #   def login pass
@@ -30,7 +30,7 @@ module Ramaze
   #   end
   # end
   #
-  # class ImportantController < Template::Ramaze
+  # class ImportantController < Controller
   #   helper :stack
   #
   #   def secret_information
@@ -47,21 +47,19 @@ module Ramaze
 
     def call this
       (session[:STACK] ||= []) << request.request_uri
-      redirect(this)
+      redirect(R(this))
     end
 
     # return to the last location on session[:STACK]
 
     def answer
-      redirect session[:STACK].pop if inside_stack?
+      redirect R(session[:STACK].pop) if inside_stack?
     end
 
     # check if the stack has something inside.
 
     def inside_stack?
-      not session[:STACK].empty?
-    rescue
-      false
+      session[:STACK] and session[:STACK].any?
     end
   end
 end

data/lib/ramaze/inform.rb

@@ -39,6 +39,8 @@ module Ramaze
 
     alias D debug
 
+    def debug?() inform_tag?(:debug) end
+
     # A little but powerful method to debug calls to methods.
     #
     #   def foo(*args)
@@ -73,6 +75,8 @@ module Ramaze
       log(Global.inform_prefix_info, message)
     end
 
+    def info?() inform_tag?(:info) end
+
     # Informing yourself about errors, you can pass it instances of Error
     # but also simple Strings.
     # (all that responds to :message/:backtrace or to_s)
@@ -103,6 +107,8 @@ module Ramaze
       end
     end
 
+    def error?() inform_tag?(:error) end
+
     # This uses Global.inform_timestamp or a date in the format of
     #   %Y-%m-%d %H:%M:%S
     #   # => "2007-01-19 21:09:32"
@@ -148,10 +154,13 @@ module Ramaze
     extend self
   end
 
+  # This class acts as a object you can pass to any other logger, it's basically
+  # just including Inform and making its methods public
+
   class GlobalInformer
     include Inform
 
-    public :error, :info, :meth_debug, :debug
+    public :error, :error?, :info, :info?, :meth_debug, :debug, :debug?
 
     # this simply sends the parameters to #debug
 
@@ -160,6 +169,8 @@ module Ramaze
     end
   end
 
+  # The usual instance of GlobalInformer, for example used for WEBrick
+
   Informer = GlobalInformer.new
 
   include Inform