Pistos-ramaze 2008.09

data/lib/ramaze/helper/form.rb

@@ -0,0 +1,281 @@
+module Ramaze
+  module Helper
+    module Form
+      # Pass it an object for your ORM and options for the <form> tag
+      # Usage:
+      #   form_for(User, :action => '/create')
+      #   form_for(Tag, :action => '/find', :method => 'GET')
+      def form_for(object, options = {})
+        Ramaze::Form.pick(object, options)
+      end
+    end
+  end
+
+  class Form
+    attr_accessor :object, :options
+
+    YEARS, MONTHS, DAYS, HOURS, MINUTES, SECONDS =
+      (1900..2100), (1..12), (1..31), (0..23), (0..59), (0..59)
+
+    DATE_GENERIC = [
+      [ :day,   DAYS ],
+      [ :month, MONTHS ],
+      [ :year,  YEARS ] ]
+
+    TIME_GENERIC = [
+      [ :day,   DAYS ],
+      [ :month, MONTHS ],
+      [ :year,  YEARS ],
+      [ :hour,  HOURS ],
+      [ :min,   MINUTES ],
+      [ :sec,   SECONDS ] ]
+
+    # TODO:
+    #   How _elegant_ ...
+    #   Tries to find the right module for extending the Form instance.
+    #   It's problematic since the boundaries of what an model instance or model
+    #   class looks like is very fuzzy, also a problem is that the ORM may not be
+    #   available/required.
+    #
+    #   Maybe we can abstract that a bit by going through an array of procs for
+    #   testing?
+    def self.pick(object, options = {})
+      if defined?(Sequel::Model)
+        if object.is_a?(Sequel::Model)
+          options[:layer] ||= Layer::Sequel
+          InstanceForm.new(object, options)
+        elsif object.ancestors.include?(Sequel::Model)
+          options[:layer] ||= Layer::Sequel
+          ClassForm.new(object, options)
+        end
+      else
+        raise "Unknown ORM for: %p" % object
+      end
+    end
+
+    # Create new instance of Form plus the layer for the ORM
+    def initialize(object, options = {})
+      @object, @options = object, options
+      if layer = options.delete(:layer)
+        extend layer
+      end
+    end
+
+    # Generate and return the final form
+    def to_s
+      out = "<form #{form_attributes}>"
+      out << "<fieldset>"
+      out << generate
+      out << "</fieldset>"
+      out << '<input type="submit" />'
+      out << '<input type="reset" />'
+      out << "</form>"
+    end
+
+    # Decide on the strucuture of the tag based on the hash
+    def field_for(hash)
+      return if hash[:primary_key]
+      args = args_for(hash)
+
+      inner =
+        case type = hash[:type]
+        when :integer
+          field_integer(*args)
+        when :boolean
+          field_boolean(*args)
+        when :text
+          field_textarea(*args)
+        when :varchar
+          field_input(*args)
+        when :date
+          field_date(*args)
+        when :time
+          field_time(*args)
+        else
+          Log.warn "Unknown field: %p" % hash
+          field_input(*args)
+        end
+
+      "<label>#{args.first}: </label>\n#{inner}"
+    end
+
+    private
+
+    # inject to attributes for the <form>
+    def form_attributes
+      options.inject([]){|s,(k,v)| s << "#{k}='#{v}'" }.join(' ')
+    end
+
+    # Start tag with name and attributes
+    def start_tag(name, hash)
+      hash.inject("<#{name}"){|s,(k,v)| s << " #{k}='#{v}'" }
+    end
+
+    # Make a closed tag with name and attributes
+    def closed_tag(name, hash)
+      start_tag(name, hash) << ' />'
+    end
+
+    # Textarea with attributes from hash and the value from @object
+    def textarea(value, hash = {})
+      start_tag(:textarea, hash) << ">#{value}</textarea>"
+    end
+
+    # <input> with optional attributes from hash
+    def input(hash = {})
+      closed_tag(:input, hash)
+    end
+
+    # <input type="checkbox" with optional attributes from hash.
+    def checkbox(hash = {})
+      hash[:type] = :checkbox
+      input(hash)
+    end
+
+    # <option value="value"> with optional attributes from hash
+    def option(value, hash = {})
+      start_tag(:option, hash) << ">#{value}</option>"
+    end
+
+    # Yield method names and values for the Date instance
+    def field_date_generic
+      DATE_GENERIC.map{|(sel, range)|
+        yield(sel, range).join
+      }.join("\n")
+    end
+
+    # Yield method names and values for the Time/DateTime instance
+    def field_time_generic
+      TIME_GENERIC.map{|(sel, range)|
+        yield(sel, range).join
+      }.join("\n")
+    end
+
+    # Here go all the layers that are extended for specific ORMs
+    module Layer
+      # Layer for Sequel, only generate needs to be implemented, may change in
+      # future if we abstract more for different ORMs
+      module Sequel
+        # A bit nasty, get the @columns of the object and generate its
+        # field_for
+        def generate
+          columns = object_class.schema.instance_variable_get('@columns')
+          columns.map{|hash| field_for(hash) }.flatten.join("<br />\n")
+        end
+      end
+    end
+  end
+
+  # Form for the model class itself, very similar to an empty instance.
+  class ClassForm < Form
+    # <input name="name" />
+    def field_input(name)
+      input :name => name
+    end
+
+    # <textarea name="name"></textarea>
+    def field_textarea(name)
+      textarea '', :name => name
+    end
+
+    # <input name="name" />
+    def field_integer(name)
+      input :name => name
+    end
+
+    # <input type="checkbox" name="name" />
+    def field_boolean(name)
+      checkbox :name => name
+    end
+
+    # <select> with lots of <option>s
+    def field_date(name)
+      field_date_generic{|sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          range.map{|d| option(d, :value => d) },
+          "</select>" ]
+      }
+    end
+
+    # <select> with lots of <option>s
+    def field_time(name)
+      field_time_generic{|sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          range.map{|d| option(d, :value => d) },
+          "</select>" ]
+      }
+    end
+
+    # picks the :name
+    def args_for(hash)
+      [ hash[:name] ]
+    end
+
+    # Should be that way, at least for Sequel
+    def object_class
+      @object
+    end
+  end
+
+  # Form for instances of the model class
+  class InstanceForm < Form
+    # <input type='text' name='name' value='value' />
+    def field_input(name, value)
+      "<input type='text' name='#{name}' value='#{value}'/>"
+    end
+
+    def field_textarea(name, value)
+      "<textarea name='#{name}'>#{value}</textarea>"
+    end
+
+    # <input type="text" name="name" value="value" />
+    def field_integer(name, value)
+      field_input(name, value)
+    end
+
+    # <input type="checkbox" ...
+    def field_boolean(name, value)
+      if value
+        checkbox :name => name, :value => value, :checked => :checked
+      else
+        checkbox :name => name, :value => value
+      end
+    end
+
+    def field_date(name, value)
+      field_date_generic do |sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          option_range_selected(range, value.send(sel)),
+          "</select>" ]
+      end
+    end
+
+    def field_time(name, value)
+      field_time_generic do |sel, range|
+        [ "<select name='#{name}[#{sel}]'>",
+          option_range_selected(range, value.send(sel)),
+          "</select>" ]
+      end
+    end
+
+    def option_range_selected(range, value)
+      range.map do |r|
+        if r == value
+          option(r, :value => r, :selected => :selected)
+        else
+          option(r, :value => r)
+        end
+      end
+    end
+
+    def args_for(hash)
+      name = hash[:name]
+      [ name, @object.send(name) ]
+    end
+
+    # Class for @object, atm Sequel specific?
+    def object_class
+      @object.class
+    end
+  end
+end

data/lib/ramaze/helper/formatting.rb

@@ -0,0 +1,158 @@
+#          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::Formatting
+
+    # Format a floating number nicely for display.
+    #
+    # Usage:
+    #   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.
+    #
+    # Usage:
+    #   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
+
+    # 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
+
+    # copied from actionpack
+    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:]]|\s|<|$)       # 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
+
+    def nl2br(string, xhtml = true)
+      br = xhtml ? '<br />' : '<br>'
+      string.gsub(/\n/, br)
+    end
+
+    # Maybe port to ruby < 1.8.7 ?
+    def obfuscate_email(string)
+      string = string.to_s
+      text = string.each_byte.map{|c| "&#%03d" % c}.join
+      %(<a href="mailto:#{string}">#{text}</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)
+
+    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
+end

data/lib/ramaze/helper/gestalt.rb

@@ -0,0 +1,15 @@
+require 'gestalt'
+
+module Ramaze
+  module Helper
+    module Gestalt
+      def gestalt(&block)
+        Ramaze::Gestalt.new(&block)
+      end
+
+      def build(&block)
+        Ramaze::Gestalt.build(&block)
+      end
+    end
+  end
+end

data/lib/ramaze/helper/gravatar.rb

@@ -0,0 +1,15 @@
+module Ramaze
+  module Helper
+    module Gravatar
+      def gravatar(email, size = 32, fallback_path = "/images/gravatar_default.jpg")
+        emailhash = Digest::MD5.hexdigest(email)
+
+        fallback = Request.current.domain
+        fallback.path = fallback_path
+        default = h(fallback.to_s)
+
+        return "http://www.gravatar.com/avatar.php?gravatar_id=#{emailhash}&default=#{default}&size=#{size}"
+      end
+    end
+  end
+end

data/lib/ramaze/helper/httpdigest.rb

@@ -0,0 +1,59 @@
+require 'uuid'
+require 'md5'
+
+module Ramaze
+  module Helper
+    module HttpDigest
+
+      @session_nonce = "authentication_digest_nonce"
+
+      def httpdigest_logout
+        session.delete( @session_nonce )
+      end
+
+      def httpdigest(uid, realm)
+        session_opaque = "authentication_digest_opaque_#{uid}"
+
+        session[session_opaque] ||= UUID.new
+
+        authorized = false
+
+        if session[@session_nonce] and request.env['HTTP_AUTHORIZATION']
+
+          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 =
+            authorization.values_at(*%w[response username nonce nc cnonce qop])
+
+          if authentication_type == 'Digest'
+            if nonce == session[@session_nonce]
+              ha1 = yield(username)
+              ha2 = MD5.hexdigest("#{request.request_method}:#{request.fullpath}")
+              md5 = MD5.hexdigest([ha1, nonce, nc, cnonce, qop, ha2].join(':'))
+
+              authorized = digest_response == md5
+            end
+          end
+        end
+
+        unless authorized
+          session[@session_nonce] = UUID.new
+          response['WWW-Authenticate'] =
+            %|Digest realm="#{realm}",| +
+            %|qop="auth,auth-int",| +
+            %|nonce="#{session[@session_nonce]}",| +
+            %|opaque="#{session[session_opaque]}"|
+          if respond_to?( :httpdigest_failure )
+            httpdigest_failure
+          else
+            respond('Unauthorized', 401)
+          end
+        end
+
+        authorization["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