ramaze 0.1.4 → 0.2.0

data/lib/ramaze/helper.rb

@@ -23,7 +23,8 @@ module Ramaze
     def helper *syms
       syms.each do |sym|
         mod_name = sym.to_s.capitalize + 'Helper'
-        require("ramaze/helper/"/sym)
+        glob = "{helper,#{BASEDIR/:ramaze/:helper}}/#{sym}.{rb,so}"
+        require Dir[glob].first
         include ::Ramaze.const_get(mod_name)
         extend ::Ramaze.const_get(mod_name)
       end

data/lib/ramaze/helper/aspect.rb

@@ -74,7 +74,7 @@ module Ramaze
     # overwrites the default Action hook and runs the neccesary blocks in its
     # scope.
     def before_process
-      return unless aspects = controller.ancestral_trait[:aspects]
+      return unless path and aspects = controller.ancestral_trait[:aspects]
       [ aspects[:before][name], aspects[:before][:all] ].compact.map do |block|
         instance.instance_eval(&block) if block
       end
@@ -83,7 +83,7 @@ module Ramaze
     # overwrites the default Action hook and runs the neccesary blocks in its
     # scope.
     def after_process
-      return unless aspects = controller.ancestral_trait[:aspects]
+      return unless path and aspects = controller.ancestral_trait[:aspects]
       [ aspects[:after][name], aspects[:after][:all] ].compact.map do |block|
         instance.instance_eval(&block) if block
       end

data/lib/ramaze/helper/auth.rb

@@ -5,12 +5,8 @@ require 'digest/sha1'
 
 module Ramaze
 
-  # A really, really, totally stupid way to do authentication. It has no
-  # roles and only a single password without usernames.
-  #
-  # It is intended to be a simple way to protect various portions of a page
-  # when you start working on it. Also it is a nice way to see how you could
-  # implement your own authentication.
+  # A simple way to do authentication. Please have a look at the docs for the
+  # check_auth method for detailed information
 
   module AuthHelper
 
@@ -32,6 +28,7 @@ module Ramaze
       username, password = request.params.values_at('username', 'password')
       if check_auth(username, password)
         session[:logged_in] = true
+        session[:username] = username
         inside_stack? ? answer : redirect( R(self) )
       else
         if AUTH_ELEMENT and AUTH_ELEMENT.to_s.split.any?
@@ -40,7 +37,7 @@ module Ramaze
         end
         %{
           #{open_element}
-            <form method="POST" action="#{R(self, :login)}"
+            <form method="POST" action="#{Rs(:login)}"
               <ul style="list-style:none;">
                 <li>Username: <input type="text" name="username" /></li>
                 <li>Password: <input type="password" name="password" /></li>
@@ -60,14 +57,14 @@ module Ramaze
       redirect_referer
     end
 
+    private
+
     # call( R(self, :login) ) if not logged in
 
     def login_required
       call(Rs(:login)) unless logged_in?
     end
 
-    private
-
     # checks if the user is already logged in.
     #   session[:logged_in] is not nil/false
 

data/lib/ramaze/helper/cache.rb

@@ -13,6 +13,42 @@ module Ramaze
       Cache.add(:value_cache) unless Cache::CACHES.has_key?(:value_cache)
     end
 
+    # Example:
+    #
+    #   class FooController < Ramaze::Controller
+    #     helper :cache
+    #     cache :index, :map_of_the_internet
+    #   end
+    #
+    # cache supports these options
+    #   [+:ttl+]  time-to-live in seconds
+    #   [+:key+]  proc that returns a key to store cache with
+    #
+    # Example:
+    #
+    #   class CacheController < Ramaze::Controller
+    #     helper :cache
+    #
+    #     # for each distinct value of request['name']
+    #     # cache rendered output of name action for 60 seconds
+    #     cache :name, :key => lambda{ request['name'] }, :ttl => 60
+    #
+    #     def name
+    #       "hi #{request['name']}"
+    #     end
+    #   end
+
+    def cache *args
+      if args.last.is_a? Hash
+        opts = args.pop
+      end
+      opts ||= {}
+
+      args.each do |arg|
+        actions_cached[arg.to_sym] = opts unless arg.nil?
+      end
+    end
+
     private
 
     # use this to cache values in your controller and templates,
@@ -22,21 +58,65 @@ module Ramaze
       Cache.value_cache
     end
 
-    # holds the values returned on the first call to a cached action.
-    # To uncache, simply delete.
+    # action_cache holds rendered output of actions for which caching is enabled.
     #
-    # Please note that the action is cached by a combination of
-    # [action, parameter].inspect - so it is a bit awkward to use.
+    # For simple cases:
     #
-    # Suggestions welcome.
+    #   class Controller < Ramaze::Controller
+    #     map '/path/to'
+    #     helper :cache
+    #     cache :action
     #
-    # Example:
+    #     def action with, params
+    #       'rendered output'
+    #     end
+    #   end
+    #
+    #   { '/path/to/action/with/params' => {
+    #       :time => Time.at(rendering),
+    #       :type => 'content/type',
+    #       :content => 'rendered output'
+    #     }
+    #   }
+    #
+    # If an additional key is provided:
+    #
+    #   class Controller < Ramaze::Controller
+    #     map '/path/to'
+    #     helper :cache
+    #     cache :action, :key => lambda{ 'value of key proc' }
     #
-    #   action_cache.delete '["index", []]'
+    #     def action
+    #       'output'
+    #     end
+    #   end
+    #
+    #   { '/path/to/action' => {
+    #       'value of key proc' => {
+    #         :time => Time.at(rendering),
+    #         :type => 'content/type',
+    #         :content => 'output'
+    #       }
+    #     }
+    #   }
+    #
+    # Caches can be invalidated after a certain amount of time
+    # by supplying a :ttl option (in seconds)
+    #
+    #   class Controller < Ramaze::Controller
+    #     helper :cache
+    #     cache :index, :ttl => 60
+    #
+    #     def index
+    #       Time.now.to_s
+    #     end
+    #   end
     #
-    # or by delete_if
+    # or by deleting values from action_cache directly
     #
-    #   action_cache.delete_if{|key, value| key =~ /"index",/}
+    #   action_cache.clear
+    #   action_cache.delete '/index'
+    #   action_cache.delete '/path/to/action'
 
     def action_cache
       Cache.actions

data/lib/ramaze/helper/cgi.rb

@@ -20,13 +20,13 @@ module Ramaze
       CGI.unescape(*args)
     end
 
-    # shortcut for GCI.escapeHTML
+    # shortcut for CGI.escapeHTML
 
     def html_escape(string)
       CGI.escapeHTML(string)
     end
 
-    # shortcut for GCI.unescapeHTML
+    # shortcut for CGI.unescapeHTML
 
     def html_unescape(string)
       CGI.unescapeHTML(string)

data/lib/ramaze/helper/formatting.rb

@@ -0,0 +1,44 @@
+#          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 FormattingHelper
+    private
+
+    def number_format(n, delimiter = ',')
+      delim_l, delim_r = delimiter == ',' ? %w[, .] : %w[. ,]
+      h, r = n.to_s.split('.')
+      [h.reverse.scan(/\d{1,3}/).join(delim_l).reverse, r].compact.join(delim_r)
+    end
+
+    # stolen and adapted from rails
+    def time_diff from_time, to_time = Time.now, include_seconds = false
+      distance_in_minutes = (((to_time - from_time).abs)/60).round
+      distance_in_seconds = ((to_time - from_time).abs).round if include_seconds
+
+      case distance_in_minutes
+        when 0..1
+          return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
+          case distance_in_seconds
+            when 0..4   then 'less than 5 seconds'
+            when 5..9   then 'less than 10 seconds'
+            when 10..19 then 'less than 20 seconds'
+            when 20..39 then 'half a minute'
+            when 40..59 then 'less than a minute'
+            else             '1 minute'
+          end
+
+        when 2..44           then "#{distance_in_minutes} minutes"
+        when 45..89          then 'about 1 hour'
+        when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
+        when 1440..2879      then '1 day'
+        when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
+        when 43200..86399    then 'about 1 month'
+        when 86400..525959   then "#{(distance_in_minutes / 43200).round} months"
+        when 525960..1051919 then 'about 1 year'
+        else                      "over #{(distance_in_minutes / 525960).round} years"
+      end
+    end
+
+  end
+end

data/lib/ramaze/helper/link.rb

@@ -20,13 +20,15 @@ module Ramaze
     # used instead. If you really want an empty href, use :href => ''
     #
     # Usage:
-    #   A('title')                  #=> <a href="/title">title</a>
-    #   A('foo/bar')                #=> <a href="/foo/bar">foo/bar</a>
-    #   A('Home', :href => Rs(:/))  #=> <a href="/foo/bar">Home</a>
+    #   A('title')                      #> <a href="/title">title</a>
+    #   A('foo/bar')                    #> <a href="/foo/bar">foo/bar</a>
+    #   A('/foo?x=y')                   #> <a href="/foo?x=y">/foo?x=y</a>
+    #   A('title', :href => '/foo?x=y') #> <a href="/foo?x=y">title</a>
+    #   A('Home', :href => Rs(:/))      #> <a href="/foo/bar">Home</a>
 
     def A(title, hash = {})
-      hash[:href] ||= Rs(title)
-      hash[:href].to_s.gsub!(/[^\/]+/){|m| CGI.escape(m) }
+      hash[:href] ||= (Rs(title) rescue title)
+      hash[:href].to_s.sub!(/\A[^\/?]+/){|m| CGI.escape(m) }
 
       args = ['']
       hash.each{|k,v| args << %(#{k}="#{v}") if k and v }

data/lib/ramaze/helper/partial.rb

@@ -37,7 +37,7 @@ module Ramaze
     def render_partial(url, options = {})
       saved = {}
       options.keys.each {|x| saved[x] = Request.current.params[x] }
-      saved_action = Thread.current[:action]
+      saved_action = Action.current
 
       Request.current.params.update(options)
 
@@ -53,13 +53,15 @@ module Ramaze
 
     def render_template(file, options = {})
       current = Action.current
-      options[:binding]     ||= current.binding
-      options[:controller]  ||= current.controller
-      options[:instance]    ||= current.instance
+      options[:controller] ||= current.controller
+      options[:instance]   ||= current.instance.dup
+      options[:binding]    ||= options[:instance].instance_eval{ binding }
       options[:template] = (options[:controller].template_root/file)
 
       action = Ramaze::Action(options)
       action.render
+    ensure
+      Thread.current[:action] = current
     end
   end
 end

data/lib/ramaze/helper/redirect.rb

@@ -9,11 +9,12 @@ module Ramaze
   #     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
+  # Usage:
+  #   redirect Rs()
+  #   redirect R(MainController)
+  #   redirect R(MainController, :foo)
   #   redirect 'foo/bar'
-  #   redirect :index, :status => 309
+  #   redirect 'foo/bar', :status => 301
   #
   # TODO:
   #   - maybe some more options, like a delay
@@ -23,22 +24,35 @@ module Ramaze
 
     private
 
+    # render to the browser directly, ignoring any templates
+    def respond *args
+      response.build(*args)
+      throw :respond
+    end
+
     # Usage:
+    #   redirect Rs()
     #   redirect R(MainController)
     #   redirect R(MainController, :foo)
     #   redirect 'foo/bar'
+    #   redirect 'foo/bar', :status => 301
 
     def redirect target, opts = {}
       target = target.to_s
-      head = {
-        'Location' => target
-      }.merge(response.header)
 
-      status = opts[:status] || STATUS_CODE["See Other"]
+      unless target =~ %r!^https?://!
+        target[0,0] = '/' unless target =~ %r!^/!
+        if host = request.env['HTTP_HOST']
+          target[0,0] = "http://#{host}"
+        end
+      end
 
+      header = {'Location' => target}
+      status = opts[:status] || STATUS_CODE["See Other"]
       body = %{You are being redirected, please follow <a href="#{target}">this link to: #{target}</a>!}
 
-      throw(:redirect, :body => body, :status => status, :head => head)
+      Inform.info("Redirect to '#{target}'")
+      throw(:redirect, [body, status, header])
     end
 
     # redirect to the location the browser says it's coming from.
@@ -46,5 +60,6 @@ module Ramaze
     def redirect_referer
       redirect request.referer
     end
+    alias redirect_referrer redirect_referer
   end
 end

data/lib/ramaze/helper/stack.rb

@@ -53,7 +53,12 @@ module Ramaze
     # return to the last location on session[:STACK]
 
     def answer
-      redirect R(session[:STACK].pop) if inside_stack?
+      if inside_stack?
+        stack = session[:STACK]
+        target = stack.pop
+        session.delete(:STACK) if stack.empty?
+        redirect target
+      end
     end
 
     # check if the stack has something inside.

data/lib/ramaze/inform/growl.rb

@@ -13,7 +13,7 @@ module Ramaze
       :name => 'walrus',
       :host => 'localhost',
       :password => 'walrus',
-      :all_notifies => %w[error warn debug info],
+      :all_notifies => %w[error warn debug info dev],
       :default_notifies => %w[error warn info]
     }
 

data/lib/ramaze/inform/informer.rb

@@ -22,8 +22,9 @@ module Ramaze
 
     # Which tag should be in what color
     COLORS = {
-      :info  => :green,
+      :dev   => :blue,
       :debug => :yellow,
+      :info  => :green,
       :warn  => :red,
       :error => :red,
     }

data/lib/ramaze/inform/informing.rb

@@ -46,6 +46,12 @@ module Ramaze
       tag_inform(:debug, :inspect, *objects)
     end
 
+    # inspects objects if they are no strings. Tag is :dev
+
+    def dev(*objects)
+      tag_inform(:dev, :inspect, *objects)
+    end
+
     alias << debug
 
     # Takes either an Exception or just a String, formats backtraces to be a bit

data/lib/ramaze/inform/syslog.rb

@@ -19,6 +19,7 @@ module Ramaze
     # alias for default syslog methods so they match ramaze
     alias error err
     alias warn warning
+    alias dev debug
 
     # just sends all messages received to ::Syslog
     def inform(tag, *args)

data/lib/ramaze/snippets/array/put_within.rb

@@ -0,0 +1,24 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class Array
+  def put_within(object, constrain)
+    pre, post = constrain.values_at(:after, :before)
+
+    unless rindex(post) - index(pre) == 1
+      raise ArgumentError, "Too many elements within constrain"
+    end
+
+    put_after(pre, object)
+  end
+
+  def put_after(element, object)
+    raise ArgumentError, "The given element doesn't exist" unless include?(element)
+    self[index(element) + 1, 0] = object
+  end
+
+  def put_before(element, object)
+    raise ArgumentError, "The given element doesn't exist" unless include?(element)
+    self[rindex(element), 0] = object
+  end
+end