ramaze 0.3.9.1 → 2008.06

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

@@ -3,12 +3,46 @@
 
 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
@@ -38,5 +72,47 @@ module Ramaze
       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
+          %(#{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
   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,48 @@
+require 'uuid'
+require 'md5'
+
+module Ramaze
+  module Helper
+    module HttpDigest
+      def httpdigest(uid, realm)
+        session_opaque = "authentication_digest_opaque_#{uid}"
+        session_nonce = "authentication_digest_nonce"
+
+        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]}"|
+          respond('Unauthorized', 401)
+        end
+
+        authorization["username"]
+      end
+    end
+  end
+end