rjspotter-ramaze 2009.06.29

data/lib/ramaze/helper/gravatar.rb

@@ -0,0 +1,79 @@
+module Ramaze
+  module Helper
+
+    # Helps you building Gravatar URIs from an email address.
+    #
+    # For more information about gravatars, please see: http://gravatar.com
+    #
+    # The implementation of the gravatar method changed significantly, it does
+    # less hand-holding but is more flexible so you can simply put your own
+    # helper on top.
+    #
+    # It might not know about all the secret parameters (like 'force'), if you
+    # find out more of these please consider contributing a patch.
+    module Gravatar
+
+      # API to build gravatar URIs from an email address (or any other String).
+      #
+      # @example Simple usage
+      #
+      #   class Gravatars < Ramaze::Controller
+      #     helper :gravatar
+      #
+      #     def index
+      #       %q(
+      #       Input your email address and I'll show you your Gravatar
+      #       <form>
+      #         <input type="text" name="email" />
+      #         <input type="submit" />
+      #       </form>
+      #       <?r if email = request[:email] ?>
+      #         Your gravatar is:
+      #         <img src="#{gravatar(email)}" />
+      #       <?r end ?>
+      #       )
+      #     end
+      #   end
+      #
+      # @option opts [#to_s] :ext (nil)
+      #   append a filename extension for the image, like '.jpg'
+      #
+      # @option opts [#to_i] :size (80)
+      #   The size of the gravatar, square, so 80 is 80x80.
+      #   Allowed range is from 1 to 512.
+      #
+      # @option opts [#to_s] :rating ('g')
+      #   Only serve a gravatar if it has a content rating equal or below the
+      #   one specified. Ratings, in order are: 'g', 'pg', 'r', or 'x'
+      #
+      # @option opts [#to_s] :default (nil)
+      #   Fall back to default if the given +email+ doesn't have an gravatar;
+      #   may be an absolute url, 'identicon', 'monsterid', or 'wavatar'
+      #
+      # @options opts [true, false] :force (false)
+      #   Force use of the default avatar, useful if you want to use only
+      #   identicons or the like
+      #
+      # @param [#to_str] email
+      #
+      # @return [URI]
+      #
+      # @see http://en.gravatar.com/site/implement/url
+      # @author manveru
+      def gravatar(email, opts = {})
+        uri = URI("http://www.gravatar.com/")
+        ext = opts[:ext]
+        uri.path = "/avatar/#{Digest::MD5.hexdigest(email.to_str)}#{ext}"
+
+        query = {}
+        query[:size]    = opts[:size].to_i.to_s if opts.key?(:size)
+        query[:rating]  = opts[:rating].to_s if opts.key?(:rating)
+        query[:default] = opts[:default].to_s if opts.key?(:default)
+        query[:force]   = '1' if opts[:force]
+
+        uri.query = Rack::Utils.build_query(query) if query.any?
+        uri
+      end
+    end
+  end
+end

data/lib/ramaze/helper/httpdigest.rb

@@ -0,0 +1,97 @@
+begin
+  require 'securerandom' # Ruby >= 1.8.7
+rescue LoadError
+  require 'uuidtools'
+end
+
+require 'digest/md5'
+
+module Ramaze
+  module Helper
+    # Authorization using HTTP Digest.
+    #
+    # For custom authorization failure handling add an {httpdigest_failure}
+    # method in your controller.
+    module HttpDigest
+
+      SESSION_NONCE = 'httpdigest_authentication_nonce'
+      SESSION_OPAQUE = 'httpdigest_authentication_opaque'
+      DIGEST_HEADER = %|Digest realm="%s", qop="auth,auth-int", nonce="%s", opaque="%s"|
+
+      # Delete the nonce and opaque from session to log out.
+      def httpdigest_logout
+        session.delete(SESSION_NONCE)
+        session.delete(SESSION_OPAQUE)
+      end
+
+      def httpdigest_uuid
+        ::SecureRandom.hex(32)
+      end
+
+      # Set the WWW-Authenticate header and store relevant data in the session.
+      #
+      # @param [String] uid
+      # @param [String] realm
+      def httpdigest_headers(uid, realm)
+        nonce = session[SESSION_NONCE] = httpdigest_uuid
+        opaque = session[SESSION_OPAQUE][realm][uid] = httpdigest_uuid
+        response['WWW-Authenticate'] = DIGEST_HEADER % [realm, nonce, opaque]
+      end
+
+      def httpdigest_failure
+        respond 'Unauthorized', 401
+      end
+
+      def httpdigest_http_authorization(uid, realm)
+        http_authorization = request.env['HTTP_AUTHORIZATION']
+        return http_authorization if http_authorization
+
+        httpdigest_headers(uid, realm)
+        httpdigest_failure
+      end
+
+      def httpdigest_lookup(username, realm)
+        if block_given?
+          yield(username)
+        elsif respond_to?(:httpdigest_lookup_password)
+          httpdigest_lookup_password(username)
+        elsif respond_to?(:httpdigest_lookup_plaintext_password)
+          plain = httpdigest_lookup_plaintext_password(username)
+          Digest::MD5.hexdigest([username, realm, plain].join(':'))
+        else
+          raise "No password lookup handler found"
+        end
+      end
+
+      def httpdigest(uid, realm, &block)
+        session[SESSION_OPAQUE] ||= {}
+        session[SESSION_OPAQUE][realm] ||= {}
+
+        http_authorization = httpdigest_http_authorization(uid, realm)
+
+        httpdigest_failure unless session_nonce = session[SESSION_NONCE]
+        httpdigest_failure unless session_opaque = session[SESSION_OPAQUE][realm][uid]
+
+        auth_type, auth_raw = http_authorization.split(' ', 2)
+        httpdigest_failure unless auth_type == 'Digest'
+
+        authorization = Rack::Auth::Digest::Params.parse(auth_raw)
+
+        digest_response, username, nonce, nc, cnonce, qop, opaque =
+          authorization.values_at(*%w[response username nonce nc cnonce qop opaque])
+
+        httpdigest_failure unless nonce == session_nonce and opaque == session_opaque
+
+        ha1 = httpdigest_lookup(username, realm, &block)
+        a2 = [request.request_method,request.request_uri]
+        a2 << Digest::MD5.hexdigest(request.body.read) if qop == "auth-int"
+        ha2 = Digest::MD5.hexdigest( a2.join(':') )
+        md5 = Digest::MD5.hexdigest([ha1, nonce, nc, cnonce, qop, ha2].join(':'))
+
+        httpdigest_failure unless digest_response == md5
+
+        return username
+      end
+    end
+  end
+end

data/lib/ramaze/helper/identity.rb

@@ -0,0 +1,119 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'openid'
+require 'openid/store/filesystem'
+require 'openid/extensions/pape'
+require 'openid/extensions/sreg'
+
+module Ramaze
+
+  openid_store_file = ::File.join(Dir.tmpdir, 'openid-store')
+
+  # Constant for storing meta-information persistent
+  OpenIDStore = OpenID::Store::Filesystem.new(openid_store_file)
+
+  # This is called Identity to avoid collisions with the original openid.rb
+  # It provides a nice and simple way to provide and control access over the
+  # OpenID authentication model.
+
+  module Helper
+    module Identity
+      LOOKUP << self
+
+      # Simple form for use or overwriting.
+      # Has to provide the same functionality when overwritten or directly
+      # embedded into a page.
+      def openid_login_form(caption="login")
+        %{
+<form method="GET" action="#{rs(:openid_begin)}">
+  Identity URL: <input type="text" name="url" />
+  <input type="submit" value="#{caption}"/>
+</form>
+        }
+      end
+
+      # We land here from the openid_login_form and if we can find a matching
+      # OpenID server we redirect the user to it, the browser will return to
+      # openid_complete when the authentication is complete.
+      def openid_begin
+        # The OpenID URL pointing to a user's OpenID page,
+        # for example: http://username.myopenid.com)
+        url = request['url']
+        redirect_referrer if url.to_s.empty?
+        session[:openid] ||= {}
+        session[:openid][:entry] = request.referrer
+
+        openid_request = openid_consumer.begin(url)
+
+        # We want these communications to be a secure as the server can
+        # support!
+        papereq = OpenID::PAPE::Request.new
+        papereq.add_policy_uri(OpenID::PAPE::AUTH_PHISHING_RESISTANT)
+        papereq.max_auth_age = 2*60*60
+        openid_request.add_extension(papereq)
+
+        # Request information about the person
+        sregreq = OpenID::SReg::Request.new
+        sregreq.request_fields(['fullname', 'nickname', 'dob', 'email',
+                               'gender', 'postcode', 'country', 'language',
+                               'timezone'])
+        openid_request.add_extension(sregreq)
+        openid_request.return_to_args['did_pape'] = 'y'
+
+        root      = "http://#{request.http_host}/"
+        return_to = request.domain(rs(:openid_complete)).to_s
+        immediate = false
+
+        if openid_request.send_redirect?(root, return_to, immediate)
+          redirect_url =
+            openid_request.redirect_url(root, return_to, immediate)
+          raw_redirect redirect_url
+        else
+          # what the hell is @form_text ?
+        end
+
+      rescue OpenID::OpenIDError => ex
+        flash[:error] = "Discovery failed for #{url}: #{ex}"
+        raw_redirect rs(:/)
+      end
+
+      # After having authenticated at the OpenID server browsers are redirected
+      # back here and on success we set the session[:openid][:identity] and a little
+      # default flash message. Then we redirect to wherever session[:openid][:entry]
+      # points us to, which was set on openid_begin to the referrer
+      #
+      # TODO:
+      #   - maybe using StackHelper, but this is a really minimal overlap?
+      def openid_complete
+        openid_response = openid_consumer.complete(request.params, request.url)
+
+        case openid_response.status
+        when OpenID::Consumer::FAILURE
+          flash[:error] = "OpenID - Verification failed: #{openid_response.message}"
+        when OpenID::Consumer::SUCCESS
+          # Backwards compatibility
+          session[:openid][:identity] = openid_response.identity_url
+          session[:openid][:sreg] = OpenID::SReg::Response.from_success_response(openid_response)
+
+          # Forward compatibility :)
+          session[:openid_identity] = openid_response.identity_url
+          session[:openid_sreg] = OpenID::SReg::Response.from_success_response(openid_response)
+
+          flash[:success] = 'OpenID - Verification done.'
+        end
+
+        session.delete(:_openid_consumer_service)
+
+        raw_redirect session[:openid][:entry]
+      end
+
+      private
+
+      # Fetch/Create a OpenID::Consumer for current session.
+      def openid_consumer
+        OpenID::Consumer.new(session, Ramaze::OpenIDStore)
+      end
+    end
+  end
+end

data/lib/ramaze/helper/layout.rb

@@ -0,0 +1,97 @@
+module Ramaze
+  module Helper
+
+    # Provides wrapper methods for a higher-level approach than the core layout
+    # method.  These are useful for simpler layout needs, particularly:
+    #
+    # * layout all actions
+    # * layout a whitelist of actions
+    # * layout all but a blacklist of actions
+    #
+    # As with the core layout method, the layout rules apply only to the
+    # controller on which they are applied.  Furthermore, multiple layout
+    # definitions are not combined; only the last definition will be used.
+    #
+    # This helper is one of the default helpers, so no explicit helper call
+    # is necessary before using it in your controllers.
+    #
+    # Usage:
+    #
+    #    class MainController < Controller
+    #      # Apply the default layout (e.g. ./layout/default.xhtml) to all
+    #      # three actions.
+    #      set_layout 'default'
+    #      def action1; end
+    #      def action2; end
+    #      def action3; end
+    #    end
+    #
+    #    class MainController < Controller
+    #      # These two layout definitions accomplish the same thing.  The
+    #      # first uses a whitelist, the second uses a blacklist.
+    #      set_layout 'default' => [:laid_out1, :laid_out2]
+    #      set_layout_except 'default' => [:not_laid_out1, :not_laid_out2]
+    #
+    #      def laid_out1; end
+    #      def laid_out2; end
+    #
+    #      def not_laid_out1; end
+    #      def not_laid_out2; end
+    #    end
+    module Layout
+      def self.included(into)
+        into.extend SingletonMethods
+      end
+
+      module SingletonMethods
+        # @param [String Hash] Either a layout name, or a single-element Hash
+        #   which maps a layout name to an Array containing a whitelist of
+        #   action names
+        # @see set_layout_except Innate::Node::layout
+        # @author Pistos, manveru
+        # @example Use a layout named 'default' on all actions of the controller:
+        #   set_layout 'default'
+        # @example Use a layout named 'default' on just the index and admin actions:
+        #   set_layout 'default' => [ :index, :admin ]
+        def set_layout(hash_or_the_layout)
+          if hash_or_the_layout.respond_to?(:to_hash)
+            f = hash_or_the_layout.first
+            the_layout = f[0]
+            whitelist = f[1].map{|action| action.to_s }
+          else
+            the_layout = hash_or_the_layout
+          end
+
+          layout do |path, wish|
+            if whitelist.nil? || whitelist.include?(path.to_s)
+              the_layout
+            end
+          end
+        end
+
+        # @param [String Hash] Either a layout name, or a single-element Hash
+        #   which maps a layout name to an Array containing a blacklist of
+        #   action names
+        # @see set_layout Innate::Node::layout
+        # @author Pistos, manveru
+        # @example Use a layout named 'default' on all actions except the user_data action:
+        #   set_layout_except 'default' => [ :user_data ]
+        def set_layout_except(hash_or_the_layout)
+          if hash_or_the_layout.respond_to?(:to_hash)
+            f = hash_or_the_layout.to_hash.first
+            the_layout = f[0]
+            blacklist = f[1].map{|action| action.to_s }
+          else
+            the_layout = hash_or_the_layout
+          end
+
+          layout do |path, wish|
+            if blacklist.nil? || !blacklist.include?(path.to_s)
+              the_layout
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/link.rb

@@ -0,0 +1,56 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'innate/helper/link'
+
+module Ramaze
+  module Helper
+    # This is a modification of Innate::Helper::Link to respect the routing of
+    # Ramaze
+    #
+    # NOTE: The A/R/Rs methods have been deprecated.
+    module Link
+      def route_location(klass)
+        prefix = Ramaze.options.prefix
+        location = Ramaze.to(klass) || Ramaze.to(klass.class)
+        [prefix, location].join('/')
+      end
+
+      # Give it a path with character to split at and one to join the crumbs with.
+      # It will generate a list of links that act as pointers to previous pages on
+      # this path.
+      #
+      # @example usage
+      #   breadcrumbs('/path/to/somewhere')
+      #
+      #   # results in this, newlines added for readability:
+      #
+      #   <a href="/path">path</a>/
+      #   <a href="/path/to">to</a>/
+      #   <a href="/path/to/somewhere">somewhere</a>
+      #
+      # Optionally a href prefix can be specified which generate link
+      # names a above, but with the prefix prepended to the href path.
+      #
+      # @example usage
+      #   breadcrumbs('/path/to/somewhere', '/', '/', '/mycontroller/action')
+      #
+      #   # results in this, newlines added for readability:
+      #
+      #   <a href="/mycontroller/action/path">path</a>/
+      #   <a href="/mycontroller/action/path/to">to</a>/
+      #   <a href="/mycontroller/action/path/to/somewhere">somewhere</a>
+      #
+      # @return [String]
+      def breadcrumbs(path, split = '/', join = '/', href_prefix = '')
+        atoms = path.split(split).reject{|a| a.empty?}
+        crumbs = atoms.inject([]){|s,v| s << [s.last,v]}
+        bread = crumbs.map do |a|
+          href_path = href_prefix + a*'/'
+          a(a[-1], href_path)
+        end
+        bread.join(join)
+      end
+    end
+  end
+end