rjspotter-ramaze 2009.06.29

data/lib/ramaze/helper/simple_captcha.rb

@@ -0,0 +1,61 @@
+module Ramaze
+  module Helper
+    # Produce very simple question/answer pairs.
+    #
+    # The default is a trivial mathematical problem.
+    #
+    # Usage (trait is optional):
+    #
+    #   class RegisterController < Ramaze::Controller
+    #     trait :captcha => lambda{
+    #       ["the answer to everything", "42"]
+    #     }
+    #
+    #     def index
+    #       %(
+    #         <form action="#{r(:answer}">
+    #           What is #{simple_captcha}?
+    #           <input type="text" name="answer" />"
+    #           <input type="submit" />
+    #         </form>
+    #       ).strip
+    #     end
+    #
+    #     def answer
+    #       check_captcha(request[:answer])
+    #     end
+    #   end
+    module SimpleCaptcha
+      include Ramaze::Traited
+
+      NUMBERS = [5, 10, 15, 20]
+
+      # lambda should return question and answer in [question, answer] form
+      trait :captcha => lambda{
+        ns = Array.new(2){ NUMBERS.sort_by{rand}.first }.sort
+        op = rand > 0.42 ? [ns[0], :+, ns[1]] : [ns[1], :-, ns[0]]
+
+        question = op.join(' ')
+        answer = op[0].send(op[1], op[2])
+
+        [question, answer]
+      }
+
+      # Call the trait[:captcha] and store question/answer in session
+      def simple_captcha
+        question, answer = ancestral_trait[:captcha].call
+
+        session[:CAPTCHA] = { :question => question, :answer => answer.to_s }
+
+        question
+      end
+
+      # check the given +answer+ against the answer stored in the session.
+      def check_captcha(answer)
+        return false unless captcha = session[:CAPTCHA]
+
+        answer.to_s.strip == captcha[:answer].to_s
+      end
+    end
+  end
+end

data/lib/ramaze/helper/stack.rb

@@ -0,0 +1,75 @@
+#          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 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
+      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
+
+      # check if the stack has something inside.
+      def inside_stack?
+        session[:STACK] and session[:STACK].any?
+      end
+    end
+  end
+end

data/lib/ramaze/helper/tagz.rb

@@ -0,0 +1,19 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'tagz'
+
+module Ramaze
+
+  # Allows you to use some shortcuts for Tagz in your Controller.
+
+  # use this inside your controller to directly build Tagz
+  # Refer to the Tagz-documentation and testsuite for more examples.
+  # Usage:
+  #   tagz { h1_{ "Apples & Oranges" } }                   #=> "<h1>Apples &amp; Oranges</h1>"
+  #   tagz { h1_(:class => 'fruits&floots'){ 'Apples' } }  #=> "<h1 class=\"fruits&amp;floots\">Apples</h1>"
+
+  module Helper
+    Tagz = ::Tagz
+  end
+end

data/lib/ramaze/helper/thread.rb

@@ -0,0 +1,17 @@
+#          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
+  module Helper::Thread
+    def thread &block
+      parent_thread = Thread.current
+      Thread.new do
+        begin
+          block.call
+        rescue Exception => e
+          parent_thread.raise(e)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/ultraviolet.rb

@@ -0,0 +1,46 @@
+module Ramaze
+  module Helper
+    module Ultraviolet
+      include Innate::Traited
+
+      trait :ultraviolet => {
+        :output       => 'xhtml',
+        :syntax       => nil, # syntax_name, nil|false indicates automatic detection
+        :line_numbers => false,
+        :style        => 'classic', # render_style
+        :headers      => false, # ouput document with all headers
+      }
+
+      # Parse and output the file at the given path.
+      # Please head over to the Ultraviolet documentation for more information
+      # on possible options.
+      def ultraviolet(path, options = {})
+        o = ancestral_trait[:ultraviolet].merge(options)
+        output, syntax, lines, style, headers =
+          o.values_at(:output, :syntax, :line_numbers, :style, :headers)
+
+        syntax ||= Uv.syntax_for_file(path).first.first
+        code = File.read(path)
+
+        p [code, output, syntax, lines, style, headers]
+        Uv.parse(code, output, syntax, lines, style, headers)
+      end
+
+      # Return absolute path to the css of given name.
+      #
+      # Usually this will point to somewhere in the gem tree.
+      #
+      # It seems like Uv will add support for user-defined PATH in the future,
+      # so we will, to be future-proof, traverse the Uv.path even though it
+      # currently will only have one directory.
+
+      def ultraviolet_css(theme)
+        Uv.path.each do |path|
+          Dir[path/"render/xhtml/files/css/*.css"].each do |css|
+            return css if File.basename(css, '.css') == theme
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/user.rb

@@ -0,0 +1,229 @@
+module Ramaze
+  module Helper
+
+    # This helper provides a convenience wrapper for handling authentication
+    # and persistence of users.
+    #
+    # 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
+    #
+    #   class Profiles < Ramaze::Controller
+    #     helper :user
+    #
+    #     def edit
+    #       redirect_referrer unless logged_in?
+    #       "Your profile is shown, your are logged in."
+    #     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
+      # 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
+        env = request.env
+        found = env[RAMAZE_HELPER_USER]
+        return found if found
+
+        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._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
+
+      # Wrapper for the ever-present "user" in your application.
+      # It wraps around an arbitrary instance and worries about authentication
+      # and storing information about the user in the session.
+      #
+      # In order to not interfere with the wrapped instance/model we start our
+      # methods with an underscore.
+      #
+      # Patches and suggestions are highly appreciated.
+      class Wrapper < BlankSlate
+        attr_accessor :_model, :_callback, :_user
+
+        def initialize(model, callback)
+          @_model, @_callback = model, callback
+          @_user = nil
+          _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
+        # @author manveru
+        def _login(creds = _persistence)
+          if @_user = _would_login?(creds)
+            self._persistence = creds
+          end
+        end
+
+        # The callback should return an instance of the user, otherwise it
+        # should answer with nil.
+        #
+        # This will not actually login, just check whether the credentials
+        # would result in a user.
+        def _would_login?(creds)
+          if c = @_callback
+            c.call(creds)
+          elsif _model.respond_to?(:authenticate)
+            _model.authenticate(creds)
+          else
+            Log.warn("Helper::User has no callback and there is no %p::authenticate" % _model)
+            nil
+          end
+        end
+
+        # @api internal
+        # @see Ramaze::Helper::User#user_logout
+        # @author manveru
+        def _logout
+          _persistence.clear
+          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?
+        # @author manveru
+        def _logged_in?
+          !!_user
+        end
+
+        def _persistence=(creds)
+          Current.session[:USER] = creds
+        end
+
+        def _persistence
+          Current.session[:USER] || {}
+        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)
+        end
+      end
+    end
+  end
+end