ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/helper/flash.rb

@@ -1,5 +1,5 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+# All files in this distribution are subject to the terms of the MIT license.
 
 module Ramaze
 
@@ -9,51 +9,54 @@ module Ramaze
   # 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:
+  # Time for an example. On the first request, for example on registering:
   #
-  # On the first request, for example on registering:
-  #
-  #   flash[:error] = "You should reconsider your username, it's taken already"
-  #   redirect R(self, :register)
+  #     flash[:error] = "You should reconsider your username, it's taken already"
+  #     redirect r(:register)
   #
   # This is the request from the redirect:
   #
-  #   do_stuff if flash[:error]
+  #     do_stuff if flash[:error]
   #
   # On the request after this, flash[:error] is gone.
 
-  module Helper::Flash
-    trait :tag => "<div class='flash' id='flash_%key'>%value</div>"
-    # answers with Session.current.flash
+  module Helper
+    module Flash
+      include Innate::Traited
 
-    def flash
-      Session.current.flash
-    end
+      trait :flashbox => "<div class='flash' id='flash_%key'>%value</div>"
 
-    # 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
+      ##
+      # Return the current value of Current.session.flash
+      #
+      def flash
+        Current.session.flash
+      end
 
-    def flashbox(tag = Helper::Flash.trait[:tag])
-      flash.map{|key, value|
-        [key.to_s, value.to_s]
-      }.sort.map{|(key, value)|
-        tag.gsub(/%key/, key.to_s).gsub(/%value/, value.to_s)
-      }.join("\n")
-    end
-  end
-end
+      # Use in your template to display all flash messages that may be stored.
+      # For example, given you stored:
+      #
+      #   flash # => { :error => 'Please 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 # Flash
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/formatting.rb

@@ -1,42 +1,207 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+# All files in this distribution are subject to the terms of the MIT license.
 
 module Ramaze
-  module Helper::Formatting
-    def number_format(n, delimiter = ',')
-      delim_l, delim_r = delimiter == ',' ? %w[, .] : %w[. ,]
-      h, r = n.to_s.split('.')
-      [h.reverse.scan(/\d{1,3}/).join(delim_l).reverse, r].compact.join(delim_r)
-    end
-
-    # stolen and adapted from rails
-    def time_diff from_time, to_time = Time.now, include_seconds = false
-      distance_in_minutes = (((to_time - from_time).abs)/60).round
-      distance_in_seconds = ((to_time - from_time).abs).round if include_seconds
-
-      case distance_in_minutes
-        when 0..1
-          return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
-          case distance_in_seconds
-            when 0..4   then 'less than 5 seconds'
-            when 5..9   then 'less than 10 seconds'
-            when 10..19 then 'less than 20 seconds'
-            when 20..39 then 'half a minute'
-            when 40..59 then 'less than a minute'
-            else             '1 minute'
+  module Helper
+    module Formatting
+      module_function
+
+      FORMATTING_NUMBER_COUNTER = {
+        0  => 'no',
+        2  => 'two',
+        3  => 'three',
+        4  => 'four',
+        5  => 'five',
+        6  => 'six',
+        7  => 'seven',
+        8  => 'eight',
+        9  => 'nine',
+        10 => 'ten'
+      }
+
+      # Answers with a representation of given +count+ with correct grammar.  If
+      # no +items+ argument is given, and the +count+ argument is not 1, then we
+      # first check whether the +item+ argument responds to ``#pluralize`` (for
+      # example if you are using Sequel). If this doesn't work we append 's'
+      # to the +item+ argument.
+      #
+      # @example usage
+      #  number_counter(0, 'comment') # => 'no comments'
+      #  number_counter(1, 'comment') # => 'one comment'
+      #  number_counter(2, 'comment') # => '2 comments'
+      #
+      def number_counter(count, item, items = nil)
+        count, item = count.to_i, item.to_s
+
+        if count == 1
+          "one #{item}"
+        else
+          items ||= item.respond_to?(:pluralize) ? item.pluralize : "#{item}s"
+          prefix = FORMATTING_NUMBER_COUNTER[count] || count
+          "#{prefix} #{items}"
+        end
+      end
+
+      # Format a floating number nicely for display.
+      #
+      # @example
+      #  number_format(123.123)           # => '123.123'
+      #  number_format(123456.12345)      # => '123,456.12345'
+      #  number_format(123456.12345, '.') # => '123.456,12345'
+      #
+      def number_format(n, delimiter = ',')
+        delim_l, delim_r = delimiter == ',' ? %w[, .] : %w[. ,]
+        h, r = n.to_s.split('.')
+        [h.reverse.scan(/\d{1,3}/).join(delim_l).reverse, r].compact.join(delim_r)
+      end
+
+      # Answer with the ordinal version of a number.
+      #
+      # @example
+      #  ordinal(1)   # => "1st"
+      #  ordinal(2)   # => "2nd"
+      #  ordinal(3)   # => "3rd"
+      #  ordinal(13)  # => "13th"
+      #  ordinal(33)  # => "33rd"
+      #  ordinal(100) # => "100th"
+      #  ordinal(133) # => "133rd"
+      #
+      def ordinal(number)
+        number = number.to_i
+
+        case number % 100
+        when 11..13; "#{number}th"
+        else
+          case number % 10
+          when 1; "#{number}st"
+          when 2; "#{number}nd"
+          when 3; "#{number}rd"
+          else    "#{number}th"
           end
+        end
+      end
 
-        when 2..44           then "#{distance_in_minutes} minutes"
-        when 45..89          then 'about 1 hour'
-        when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
-        when 1440..2879      then '1 day'
-        when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
-        when 43200..86399    then 'about 1 month'
-        when 86400..525959   then "#{(distance_in_minutes / 43200).round} months"
-        when 525960..1051919 then 'about 1 year'
-        else                      "over #{(distance_in_minutes / 525960).round} years"
+      # stolen and adapted from rails
+      def time_diff(from_time, to_time = Time.now, include_seconds = false)
+        distance_in_minutes = (((to_time - from_time).abs)/60).round
+        distance_in_seconds = ((to_time - from_time).abs).round if include_seconds
+
+        case distance_in_minutes
+          when 0..1
+            return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
+            case distance_in_seconds
+              when 0..4   then 'less than 5 seconds'
+              when 5..9   then 'less than 10 seconds'
+              when 10..19 then 'less than 20 seconds'
+              when 20..39 then 'half a minute'
+              when 40..59 then 'less than a minute'
+              else             '1 minute'
+            end
+
+          when 2..44           then "#{distance_in_minutes} minutes"
+          when 45..89          then 'about 1 hour'
+          when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
+          when 1440..2879      then '1 day'
+          when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
+          when 43200..86399    then 'about 1 month'
+          when 86400..525959   then "#{(distance_in_minutes / 43200).round} months"
+          when 525960..1051919 then 'about 1 year'
+          else                      "over #{(distance_in_minutes / 525960).round} years"
+        end
       end
-    end
 
-  end
-end
+      # Copied from actionpack, and revised by insane-dreamer to fix a bug
+      # (original fails on some URLs)
+      AUTO_LINK_RE = %r{
+        (                          # leading text
+          <\w+.*?>|                # leading HTML tag, or
+          [^=!:'"/]|               # leading punctuation, or
+          ^                        # beginning of line
+        )
+        (
+          (?:https?://)|           # protocol spec, or
+          (?:www\.)                # www.*
+        )
+        (
+          [-\w]+                   # subdomain or domain
+          (?:\.[-\w]+)*            # remaining subdomains or domain
+          (?::\d+)?                # port
+          (?:/(?:[~\w\+@%=\(\)-]|(?:[,.;:'][^\s<$]))*)* # path
+          (?:\?[\w\+@%&=.;:-]+)?   # query string
+          (?:\#[\w\-]*)?           # trailing anchor
+        )
+        ([[:punct:]]|<|$|)         # trailing text
+      }x unless defined? AUTO_LINK_RE
+
+      # Turns all urls into clickable links.  If a block is given, each url
+      # is yielded and the result is used as the link text.
+      def auto_link(text, opts = {})
+        html_options = ' ' + opts.map{|k,v| "#{k}='#{v}'"}.join(' ') if opts.any?
+        text.gsub(AUTO_LINK_RE) do
+          all, a, b, c, d = $&, $1, $2, $3, $4
+          if a =~ /<a\s/i # don't replace URL's that are already linked
+            all
+          else
+            text = b + c
+            text = yield(text) if block_given?
+            %(#{a}<a href="#{b=="www."?"http://www.":b}#{c}"#{html_options}>#{text}</a>#{d})
+          end
+        end
+      end
+      alias autolink auto_link
+
+      # takes a string and optional argument for outputting compliance HTML
+      # instead of XHTML.
+      #
+      # @example
+      #  nl2br "a\nb\n\c" #=> 'a<br />b<br />c'
+      #
+      def nl2br(string, xhtml = true)
+        br = xhtml ? '<br />' : '<br>'
+        string.gsub(/\n/, br)
+      end
+
+      def obfuscate_email(email, text = nil)
+        obfuscated = []
+        email.to_s.each_byte{|c| obfuscated << "&#%03d" % c }
+        joined = obfuscated.join
+
+        %(<a href="mailto:#{joined}">#{text || joined}</a>)
+      end
+
+      # Returns Hash with tags as keys and their weight as value.
+      #
+      # Example:
+      #     tags = %w[ruby ruby code ramaze]
+      #     tagcloud(tags)
+      #     # => {"code"=>0.75, "ramaze"=>0.75, "ruby"=>1.0}
+      #
+      # The weight can be influenced by adjusting the +min+ and +max+
+      # parameters, please make sure that +max+ is larger than +min+ to get
+      # meaningful output.
+      #
+      # This is not thought as immediate output to your template but rather to
+      # help either implementing your own algorithm or using the result as input
+      # for your tagcloud.
+      #
+      # @example
+      #  tagcloud(tags).each do |tag, weight|
+      #    style = "font-size: %0.2fem" % weight
+      #    %a{:style => style, :href => Rs(tag)}= h(tag)
+      #  end
+      #
+      def tagcloud(tags, min = 0.5, max = 1.5)
+        result = {}
+        total = tags.size.to_f
+        diff = max - min
+
+        tags.uniq.each do |tag|
+          count = tags.respond_to?(:count) ? tags.count(tag) : tags.select{|t| t==tag }.size
+          result[tag] = ((count / total) * diff) + min
+        end
+
+        result
+      end
+    end # Formatting
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/gestalt.rb

@@ -0,0 +1,49 @@
+require 'ramaze/gestalt'
+
+module Ramaze
+  module Helper
+    # Gestalt is the custom HTML/XML builder for Ramaze, based on a very simple 
+    # DSL it will build your markup.
+    module Gestalt
+      CACHE_G = {}
+
+      def gestalt(&block)
+        Ramaze::Gestalt.new(&block)
+      end
+
+      def build(&block)
+        Ramaze::Gestalt.build(&block)
+      end
+
+      def g(meth = nil, view = nil)
+        meth ||= caller[0].slice(/`(.*)'?/).gsub(/[\`\']/, '')
+        view_name = (self.class.to_s.sub('Controller', '') + 'View').split('::')
+        view ||= view_name.inject(Object){ |ns, name| ns.const_get(name) }
+
+        gestalt_class = CACHE_G[view] ||= g_class
+        gestalt = gestalt_class.new
+        gestalt.extend(view)
+        instance_variables.each do |iv|
+          gestalt.instance_variable_set(iv, instance_variable_get(iv))
+        end
+        gestalt.__send__(meth)
+        gestalt.to_s
+      end
+
+      def g_class
+        ancs = self.class.ancestors
+        helpers = Ramaze::Helper.constants.map{ |c| Ramaze::Helper.const_get(c)}
+        our_helpers = ancs & helpers
+        our_helpers.delete(Ramaze::Helper::Gestalt)
+        gestalt_class = Class.new(Ramaze::Gestalt){ include(*our_helpers) }
+      end
+
+      def method_missing(sym, *args, &block)
+        @gestalt ||= gestalt
+        @gestalt.send(sym, *args, &block)
+      end
+    end
+  end
+end
+
+module Ramaze::Helper::Link; undef :a end

data/lib/ramaze/helper/gravatar.rb

@@ -0,0 +1,75 @@
+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'
+      #
+      # @option 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 # Gravatar
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/identity.rb

@@ -1,13 +1,14 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+# All files in this distribution are subject to the terms of the MIT 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')
+  openid_store_file = ::File.join(Ramaze.options.roots[0], '/tmp', 'openid-store')
 
   # Constant for storing meta-information persistent
   OpenIDStore = OpenID::Store::Filesystem.new(openid_store_file)
@@ -16,79 +17,103 @@ module Ramaze
   # It provides a nice and simple way to provide and control access over the
   # OpenID authentication model.
 
-  module Helper::Identity
+  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)}">
+      # 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
-      url = request['url']
-      redirect_referrer if url.to_s.empty?
-      session[:openid_entry] = request.referrer
-
-      openid_request = openid_consumer.begin(url)
-
-      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)
-      openid_request.return_to_args['did_pape'] = 'y'
-
-      root         = "http://#{request.http_host}/"
-      return_to    = root[0..-2] + Rs(:openid_complete)
-      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.request_uri)
-
-      case openid_response.status
-      when OpenID::Consumer::FAILURE
-        flash[:error] = 'OpenID - Verification failed.'
-      when OpenID::Consumer::SUCCESS
-        session[:openid_identity] = openid_response.identity_url
-        flash[:success] = 'OpenID - Verification done.'
+      # 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
 
-      session.delete(:_openid_consumer_service)
-
-      raw_redirect session[:openid_entry]
-    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
+      private
 
-    # Fetch/Create a OpenID::Consumer for current session.
-    def openid_consumer
-      OpenID::Consumer.new(session, Ramaze::OpenIDStore)
-    end
-  end
-end
+      # Fetch/Create a OpenID::Consumer for current session.
+      def openid_consumer
+        OpenID::Consumer.new(session, Ramaze::OpenIDStore)
+      end
+    end # Identity
+  end # Helper
+end # Ramaze