manveru-ramaze 2009.01 → 2009.04

data/lib/ramaze/helper/httpdigest.rb

@@ -1,88 +1,97 @@
-require 'uuid'
-require 'md5'
+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
 
-      UUID_GENERATOR = UUID.new
-
       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 )
+        session.delete(SESSION_NONCE)
+        session.delete(SESSION_OPAQUE)
       end
 
-      def httpdigest_headers uid, realm
-        session[ SESSION_NONCE ] = UUID_GENERATOR.generate
-        session[ SESSION_OPAQUE ][ realm ][ uid ] = UUID_GENERATOR.generate
-        response['WWW-Authenticate'] =
-          %|Digest realm="#{realm}",| +
-          %|qop="auth,auth-int",| +
-          %|nonce="#{session[SESSION_NONCE]}",| +
-          %|opaque="#{session[SESSION_OPAQUE][realm][uid]}"|
+      def httpdigest_uuid
+        ::SecureRandom.hex(32)
       end
 
-      def httpdigest(uid, realm)
-        session[ SESSION_OPAQUE ] ||= {}
-        session[ SESSION_OPAQUE ][ realm ] ||= {}
-
-        if request.env['HTTP_AUTHORIZATION']
-
-          authorized = false
-
-          if session[ SESSION_NONCE ] and session[ SESSION_OPAQUE ][ realm ][ uid ]
-
-            auth_split = request.env['HTTP_AUTHORIZATION'].split
-            authentication_type = auth_split[0]
-            authorization = Rack::Auth::Digest::Params.parse( auth_split[1..-1].join(' ') )
-
-            digest_response, username, nonce, nc, cnonce, qop, opaque =
-              authorization.values_at(*%w[response username nonce nc cnonce qop opaque])
-
-            if authentication_type == 'Digest'
-              if nonce == session[SESSION_NONCE] and opaque == session[SESSION_OPAQUE][realm][uid]
-                h1 = nil
-                if respond_to?( :httpdigest_lookup_password )  
-                  ha1 = httpdigest_lookup_password( username )
-                else
-                  if respond_to?( :httpdigest_lookup_plaintext_password )
-                    ha1 = MD5.hexdigest( "#{username}:#{realm}:#{httpdigest_lookup_plaintext_password( username )}" )
-                  else
-                    if block_given?
-                      ha1 = yield( username )
-                    else
-                      raise "No password lookup handler found"
-                    end
-                  end
-                end
-                ha2 = MD5.hexdigest([request.request_method,request.fullpath].join(':'))
-                md5 = MD5.hexdigest([ha1, nonce, nc, cnonce, qop, ha2].join(':'))
-
-                authorized = digest_response == md5
-              end
-            end
-
-          end
-
-          unless authorized
-            httpdigest_headers( uid, realm )
-            respond('Unauthorized', 401)
-          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
 
-        else
+      def httpdigest_failure
+        respond 'Unauthorized', 401
+      end
 
-          httpdigest_headers( uid, realm )
-          httpdigest_failure if respond_to?( :httpdigest_failure )
-          respond('Unauthorized', 401)
+      def httpdigest_http_authorization(uid, realm)
+        http_authorization = request.env['HTTP_AUTHORIZATION']
+        return http_authorization if http_authorization
 
-        end
+        httpdigest_headers(uid, realm)
+        httpdigest_failure
+      end
 
-        authorization["username"]
+      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/link.rb

@@ -1,122 +1,75 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          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
-  # Helper::Link is included into the Controller by default
-  #
-  # Usage is shown in spec/ramaze/helper/link.rb and the rdocs below.
-
-  module Helper::Link
-    # Builds a basic <a> tag.
-    #
-    # `text` is mandatory, the second hash of options will be transformed into
-    # arguments of the tag, :href is a special case and its segments will be
-    # escaped.
-    #
-    # If you pass no :href, the text will be run through Rs and its result is
-    # used instead. If you really want an empty href, use :href => ''
-    #
-    # Usage:
-    #   A('text')                       #> <a href="/text">text</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('text', :href => '/foo?x=y')  #> <a href="/foo?x=y">text</a>
-    #   A('Home', :href => Rs(:/))      #> <a href="/foo/bar">Home</a>
-
-    def A(*args)
-      hash = args.last.respond_to?(:to_hash) ? args.pop : {}
-
-      hash[:href] ||= Rs(*args)
-      text = hash.delete(:text) || args.last || hash[:title] || hash[:href]
-      hash[:href] = hash[:href].to_s.gsub(/[^\/?;=]+/){|m| Rack::Utils.escape(m) }
-
-      args = ['']
-      hash.each {|k,v| args << %(#{k}="#{v}") if k and v }
-
-      %(<a#{args.join(' ')}>#{text}</a>)
-    end
-
-    # Builds links out of segments.
-    #
-    # Pass it strings, symbols, controllers and it will produce a link out of
-    # it. Paths to Controllers are obtained from Global.mapping.
-    #
-    # For brevity, the mapping for the example below is following:
-    #   { MC => '/', OC => '/o', ODC => '/od' }
-    #
-    # Usage:
-    #   R(MC) #=> '/'
-    #   R(OC) #=> '/o'
-    #   R(ODC) #=> '/od'
-    #   R(MC, :foo) #=> '/foo'
-    #   R(OC, :foo) #=> '/o/foo'
-    #   R(ODC, :foo) #=> '/od/foo'
-    #   R(MC, :foo, :bar => :x) #=> '/foo?bar=x'
-
-    def R(*atoms)
-      args, atoms = atoms.flatten.partition{|a| a.is_a?(Hash) }
-      args = args.flatten.inject{|s,v| s.merge!(v) }
+require 'innate/helper/link'
 
-      map = Global.mapping.invert
-
-      atoms.map! do |atom|
-        if atom.is_a?(Ramaze::Controller)
-          map[atom.class]
-        else
-          map[atom]
-        end or atom.to_s
+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
+
+      # @return [String]
+      # @see Innate::Helper#anchor
+      def A(*args)
+        Ramaze.deprecated('Ramaze::Helper::Link#A', 'Ramaze::Helper::Link#a')
+        a(*args)
       end
 
-      front = [Global.prefix, *atoms].join('/').squeeze('/')
-
-      if args
-        rear = args.inject('?'){|s,(k,v)| s << "#{Rack::Utils.escape(k)}=#{Rack::Utils.escape(v)};"}[0..-2]
-        front + rear
-      else
-        front
+      # @return [String]
+      # @see Innate::Helper#route
+      def R(arg, *args)
+        Ramaze.deprecated('Ramaze::Helper::Link#R', 'Ramaze::Helper::Link#r')
+        (arg < Controller ? arg.r(*args) : r(arg, *args)).to_s
       end
-    end
 
-    # Uses R with Controller.current as first element.
-
-    def Rs(*atoms)
-      atoms.unshift Controller.current unless atoms.first.is_a?(Controller)
-      R(*atoms)
-    end
+      # @return [String]
+      # @see Innate::Helper#route
+      def Rs(*args)
+        Ramaze.deprecated('Ramaze::Helper::Link#Rs', 'Ramaze::Helper::Link#r')
+        r(*args).to_s
+      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:
-    #   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:
-    #   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>
+      def route_location(klass)
+        Ramaze.to(klass) || Ramaze.to(klass.class)
+      end
 
-    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=>(href_path))
+      # 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:
+      #   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:
+      #   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
-      bread.join(join)
     end
   end
 end

data/lib/ramaze/helper/localize.rb

@@ -0,0 +1,138 @@
+require 'locale/tag'
+require 'locale'
+
+module Ramaze
+  module Helper
+    module Localize
+      include Traited
+
+      trait :localize_locale => ::Locale::Tag::Simple.new('en')
+      trait :localize_charset => 'UTF-8'
+
+      def localize(string, substitute = nil)
+        localize_dictionary.translate(string, locales, substitute)
+      end
+      alias l localize
+
+      def locale
+        locales.first
+      end
+
+      def locales
+        locales = request.env['localize.locales']
+        return locales if locales
+
+        fallback = ancestral_trait[:localize_locale]
+        locales = Parser.new(request).locales(fallback)
+        request.env['localize.locales'] = locales
+      end
+
+      class Dictionary
+        attr_reader :dict
+
+        def initialize
+          @dict = {}
+        end
+
+        def translate(string, locales, substitute)
+          target = string.to_s.dup
+          locales = locales.flatten.uniq
+
+          if substitute
+            substitute.each do |key, value|
+              target.gsub!(/\{#{Regexp.escape(key)}\}/, lookup(value, locales))
+            end
+            return target
+          elsif target =~ /\{/
+            target.gsub!(/\{([^\}]+)\}/){ lookup($1, locales) }
+            return target
+          else
+            lookup(target, locales)
+          end
+        end
+
+        def lookup(string, locales)
+          locales.each do |locale|
+            next unless dict = self[locale]
+            next unless translated = dict[string]
+            return translated
+          end
+
+          string
+        end
+
+        def locales
+          @dict.keys
+        end
+
+        def [](locale)
+          @dict[arg_to_locale(locale)]
+        end
+
+        def []=(locale, dict)
+          @dict[arg_to_locale(locale)] = dict
+        end
+
+        def load(locale, options = {})
+          if file = options.delete(:yaml)
+            dict = ::YAML.load_file(file)
+          elsif hash = options.delete(:hash)
+            dict = hash
+          elsif marshal = options.delete(:marshal)
+            dict = Marshal.load(File.read(marshal))
+          else
+            raise ArgumentError, "either :yaml, :marshal, or :hash"
+          end
+
+          @dict[arg_to_locale(locale)] = dict
+        end
+
+        private
+
+        def arg_to_locale(arg, raises = true)
+          if raises and not arg
+            raise(ArgumentError, "%p cannot be converted to a Locale" % arg)
+          end
+          arg.respond_to?(:language) ? arg : ::Locale::Tag.parse(arg.to_s)
+        end
+      end
+
+      class Parser
+        attr_accessor :request
+
+        def initialize(request)
+          @request = request
+        end
+
+        def locales(fallback = nil)
+          locales = [parse, fallback].flatten.uniq
+          ::Locale::TagList.new(locales)
+        end
+
+        def parse
+          parse_params || parse_session || parse_cookie || parse_header
+        end
+
+        def parse_params(key = 'lang')
+          return unless lang = request.params[key]
+          ::Locale::Tag.parse(lang)
+        end
+
+        def parse_session(key = :lang)
+          return unless lang = Current.session[key]
+          ::Locale::Tag.parse(lang)
+        end
+
+        def parse_cookie(key = 'lang')
+          return unless lang = request.cookies[key]
+          ::Locale::Tag.parse(lang)
+        end
+
+        def parse_header
+          request.accept_language.map{|lang|
+            ::Locale::Tag.parse(lang) }
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/markaby.rb

@@ -15,7 +15,7 @@ module Ramaze
     def markaby(ivs = {}, helpers = nil, &block)
       builder = ::Markaby::Builder
       builder.extend(Ramaze::Helper::Methods)
-      builder.send(:helper, :redirect, :link, :sendfile, :flash, :cgi, :partial)
+      builder.send(:helper, :link)
 
       iv_hash = {}
       instance_variables.each do |iv|

data/lib/ramaze/helper/maruku.rb

@@ -1,9 +1,16 @@
 require 'maruku'
 
 module Ramaze
-  module Helper::Maruku
-    def maruku(text)
-      Maruku.new(text).to_html
+  module Helper
+    module Maruku
+      # Shortcut to generate HTML from Markdown code using Maruku
+      #
+      # @param [#to_str] text the markdown to be converted
+      # @return [String] html generated from +text+
+      # @author manveru
+      def maruku(text)
+        ::Maruku.new(text.to_str).to_html
+      end
     end
   end
 end

data/lib/ramaze/helper/pager.rb

@@ -83,6 +83,7 @@ module Ramaze
 
 class Pager
   include Ramaze::Helper::Link
+  include Ramaze::Traited
 
   # Items per page.
 
@@ -255,7 +256,7 @@ private
 
   def target_uri(page)
     params = @request.params.merge(@key => page)
-    Rs(Action.current.name, params)
+    Current.action.node.r(Current.action.name, params)
   end
 
   # Generate link for the first page.

data/lib/ramaze/helper/paginate.rb

@@ -9,6 +9,7 @@ module Ramaze
     # Also have a look at the examples/helpers/paginate.rb
 
     module Paginate
+      include Traited
 
       # Define default options in your Controller, they are being retrieved by
       # ancestral_trait, so you can also put it into a common superclass
@@ -62,8 +63,8 @@ module Ramaze
       # Provides easy pagination and navigation
 
       class Paginator
-        include Ramaze::Helper::Link
-        include Ramaze::Helper::CGI
+        include Ramaze::Helper
+        helper :link, :cgi
 
         def initialize(data = [], page = 1, limit = 10, var = 'pager')
           @data, @page, @limit, @var = data, page, limit, var
@@ -142,11 +143,18 @@ module Ramaze
           @pager.page_count > 1
         end
 
-        # Forward everything to the inner @pager
+        # these methods are actually on the pager, but we def them here for
+        # convenience (method_missing in helper is evil and even slower)
 
-        def method_missing(meth, *args, &block)
-          @pager.send(meth, *args, &block)
-        end
+        def page_count; @pager.page_count end
+        def each(&block) @pager.each(&block) end
+        def first_page?; @pager.first_page?; end
+        def prev_page; @pager.prev_page; end
+        def current_page; @pager.current_page; end
+        def last_page; @pager.last_page; end
+        def last_page?; @pager.last_page?; end
+        def next_page; @pager.next_page; end
+        def empty?; @pager.empty?; end
 
         private
 
@@ -164,9 +172,9 @@ module Ramaze
         def link(n, text = n, hash = {})
           text = h(text.to_s)
 
-          params = Ramaze::Request.current.params.merge(@var.to_s => n)
-          name = Ramaze::Request.current.path_info
-          hash[:href] = R(name, params)
+          action = Current.action
+          params = request.params.merge(@var.to_s => n)
+          hash[:href] = action.node.r(action.name, params)
 
           g.a(hash){ text }
         end