Pistos-ramaze 2008.09

data/lib/ramaze/helper/aspect.rb

@@ -0,0 +1,106 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # A helper that provides the means to wrap actions of the controller with
+  # other methods.
+  #
+  # For examples please look at the spec/ramaze/helper/aspect.rb
+  #
+  # Like every other helper, you can use it in your controller with:
+  #
+  #   helper :aspect
+
+  module Helper::Aspect
+
+    private
+
+    # 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
+
+    # run block before given actions or, if no actions specified, all actions.
+    def before(*meths, &block)
+      return before_all(*meths, &block) if meths.empty?
+      meths.each do |meth|
+        aspects[:before][meth.to_s] = block
+      end
+    end
+    alias pre before
+
+    # Run block before all actions.
+    def before_all(&block)
+      aspects[:before][:all] = block
+    end
+    alias pre_all before_all
+
+    # run block after given actions or, if no actions specified, all actions.
+    def after(*meths, &block)
+      return after_all(*meths, &block) if meths.empty?
+      meths.each do |meth|
+        aspects[:after][meth.to_s] = block
+      end
+    end
+    alias post after
+
+    # Run block after all actions.
+    def after_all(&block)
+      aspects[:after][:all] = block
+    end
+    alias post_all after_all
+
+    # 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)
+      aspects[:before][:all] = block
+      aspects[:after][:all] = block
+    end
+  end
+
+  class Action
+
+    # overwrites the default Action hook and runs the neccesary blocks in its
+    # scope. before actions are run starting from Ramaze::Controller down the
+    # ancestor chain.
+    def before_process
+      common_aspect(:before)
+    end
+
+
+    # overwrites the default Action hook and runs the neccesary blocks in its
+    # scope. before actions are run starting from Ramaze::Controller down the
+    # ancestor chain.
+    def after_process
+      common_aspect(:after)
+    end
+
+    def common_aspect(aspect)
+      return unless path
+
+      controller.relevant_ancestors.reverse_each do |controller|
+        next unless aspects = controller.trait[:aspects]
+
+        [ aspects[aspect][name], aspects[aspect][:all] ].compact.map do |block|
+          instance.instance_eval(&block) if block
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/helper/auth.rb

@@ -0,0 +1,125 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'digest/sha1'
+
+module Ramaze
+
+  # A simple way to do authentication. Please have a look at the docs for the
+  # check_auth method for detailed information
+
+  module Helper::Auth
+    Helper::LOOKUP << self
+
+    # add Helper::Aspect and Helper::Stack on inclusion of Helper::Auth
+
+    def self.included(klass)
+      klass.send(:helper, :aspect, :stack)
+    end
+
+    # The default Element to use (if any)
+
+    AUTH_ELEMENT = 'Page'
+
+    # action for login, takes a password
+    # ( ?password=passwort or /login/passwort or via a form )
+    # if no password given, shows a simple form to input it.
+
+    def login
+      username, password = request[:username, :password]
+      if check_auth(username, password)
+        session[:logged_in] = true
+        session[:username] = username
+        inside_stack? ? answer : redirect_referrer
+      else
+        if defined? AUTH_ELEMENT and AUTH_ELEMENT.to_s.split.any?
+          open_element = "<#{AUTH_ELEMENT}>"
+          close_element = "</#{AUTH_ELEMENT}>"
+        end
+        %{
+          #{open_element}
+            <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>
+                <li><input type="submit" /></li>
+              </ul>
+            </form>
+          #{close_element}
+        }
+      end
+    end
+
+    # clear the session and redirect to the index action of the mapping of the
+    # current controller.
+
+    def logout
+      session.clear
+      redirect_referer
+    end
+
+    private
+
+    # call( R(self, :login) ) if not logged in
+
+    def login_required
+      call(Rs(:login)) unless logged_in?
+    end
+
+    # checks if the user is already logged in.
+    #   session[:logged_in] is not nil/false
+
+    def logged_in?
+      !!session[:logged_in]
+    end
+
+    # check the authentication (username and password) against the auth_table.
+    #
+    # auth_table is a trait, it may be the name of a method, a Proc or a simple
+    # 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 Digest::SHA1.hexdigest.
+    #
+    # The method and Proc are both called on demand.
+    #
+    # If you want to change the way the password is hashed, change
+    #   trait[:auth_hashify]
+    #
+    # The default looks like:
+    #   lambda{ |pass| Digest::SHA1.hexdigest(pass.to_s) }
+    #
+    # As with the auth_table, this has to be an object that responds to #[]
+    #
+    # If you want all your controllers to use the same mechanism set the trait
+    # on one of the ancestors, the traits are looked up by #ancestral_trait
+    #
+    # Examples:
+    #
+    #   # The method to be called.
+    #   trait :auth_table => :auth_table
+    #   trait :auth_table => 'auth_table'
+    #
+    #   # Lambda that will be called upon demand
+    #   trait :auth_table => lambda{ {'manveru' => Digest::SHA1.hexdigest 'password'} }
+    #
+    #   # Hash holding the data.
+    #   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)
+      auth_table = method(auth_table) if auth_table.respond_to?(:to_str)
+      auth_table = auth_table.call    if auth_table.respond_to?(:call)
+
+      default_hashify = lambda{ |pass| Digest::SHA1.hexdigest(pass.to_s) }
+
+      hashify  = (ancestral_trait[:auth_hashify] ||= default_hashify)
+      password = hashify[pass.to_s]
+
+      auth_table[user.to_s] == password
+    end
+  end
+end

data/lib/ramaze/helper/cache.rb

@@ -0,0 +1,140 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # This helper is providing easy access to a couple of Caches to use for
+  # smaller amounts of data.
+
+  module Helper::Cache
+    C = Ramaze::Cache
+
+    # Create the Cache.value_cache on inclusion if it doesn't exist yet.
+    def self.included(klass)
+      C.add(:value_cache) unless C::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
+    #
+    # cache acts as a wrapper for value_cache if no args are given
+
+    def cache *args
+      return value_cache if args.size == 0
+
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+
+      args.compact.each do |arg|
+        actions_cached[arg.to_sym] = opts
+      end
+    end
+
+    private
+
+    # use this to cache values in your controller and templates,
+    # for example heavy calculations or time-consuming queries.
+
+    def value_cache
+      C.value_cache
+    end
+
+    # action_cache holds rendered output of actions for which caching is enabled.
+    #
+    # For simple cases:
+    #
+    #   class Controller < Ramaze::Controller
+    #     map '/path/to'
+    #     helper :cache
+    #     cache :action
+    #
+    #     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' }
+    #
+    #     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 deleting values from action_cache directly
+    #
+    #   action_cache.clear
+    #   action_cache.delete '/index'
+    #   action_cache.delete '/path/to/action'
+
+    def action_cache
+      C.actions
+    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/cgi.rb

@@ -0,0 +1,39 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # Shortcuts to some CGI methods
+
+  module Helper::CGI
+
+    # shortcut for Rack::Utils.escape
+    def url_encode(*args)
+      Rack::Utils.escape(*args.map{|a| a.to_s })
+    end
+
+    # shortcut for Rack::Utils.unescape
+    def url_decode(*args)
+      Rack::Utils.unescape(*args.map{|a| a.to_s })
+    end
+
+    # shortcut for Rack::Utils.escape_html
+    def html_escape(string)
+      Rack::Utils.escape_html(string)
+    end
+
+    # shortcut for CGI.unescapeHTML
+    def html_unescape(string)
+      ::CGI.unescapeHTML(string.to_s)
+    end
+
+    # safely escape all HTML and code
+    def h(string)
+      Rack::Utils.escape_html(string).gsub(/#([{@$]@?)/, '#\1')
+    end
+
+    # one-letter versions help in case like #{h foo.inspect}
+    # ERb/ERuby/Rails compatible
+    alias u url_encode
+  end
+end

data/lib/ramaze/helper/flash.rb

@@ -0,0 +1,59 @@
+#          Copyright (c) 2008 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 Helper::Flash
+    trait :flashbox => "<div class='flash' id='flash_%key'>%value</div>"
+    # answers with Session.current.flash
+
+    def flash
+      Session.current.flash
+    end
+
+    # Use in your template to display all flash messages that may be stored.
+    # For example, given you stored:
+    #
+    #   flash # => { :error => 'Pleae enter your name'
+    #                :info => 'Do you see the fnords?' }
+    #
+    # Then a flashbox would display:
+    #
+    #   <div class='flash' id='flash_error'>Please enter your name</div>
+    #   <div class='flash' id='flash_info'>Do you see the fnords?</div>
+    #
+    # This is designed to be customized permanently or per usage:
+    #
+    #   flashbox("<div class='flash_%key'>%value</div>")
+    #
+    # Where any occurrence of %key and %value will be replaced by the actual
+    # contents of each element of flash
+
+    def flashbox(tag = ancestral_trait[:flashbox])
+      flash.map{|key, *values|
+        values.flatten.map do |value|
+          tag.gsub(/%key/, key.to_s).gsub(/%value/, value.to_s)
+        end
+      }.flatten.join("\n")
+    end
+  end
+end