clivecrous-ramaze 0.3.9.5

data/lib/ramaze/helper.rb

@@ -0,0 +1,78 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/trinity'
+
+module Ramaze
+
+  # 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 = ['']
+    trait :ignore => [
+      /#{Regexp.escape(File.expand_path(BASEDIR/'../spec/ramaze/helper/'))}\//
+    ]
+
+    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, "#{name} not found"
+            end
+          end
+        end
+      end
+
+      private
+
+      def find_helper(name)
+        ramaze_helper_consts = ::Ramaze::Helper.constants.grep(/^#{name}$/i)
+        if mod_name = ramaze_helper_consts.first
+          ::Ramaze::Helper.const_get(mod_name)
+        end
+      end
+
+      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, "#{name} not found" unless file = files.first
+        require(file)
+      end
+
+      def use_helper(mod)
+        include mod
+        extend mod
+      end
+    end
+  end
+end

data/lib/ramaze/helper/aspect.rb

@@ -0,0 +1,110 @@
+#          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
+  #
+  # This is not a default helper due to the possible performance-issues.
+  # However, it should be only an overhead of about 6-8 calls, so if you
+  # want this feature it shouldn't have too large impact ;)
+  #
+  # 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