manveru-ramaze 2009.01 → 2009.04

data/lib/ramaze/helper/form.rb

@@ -1,284 +1,115 @@
+require 'ramaze/gestalt'
+
 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)
+      def form_text(label, name, value = nil)
+        form_input(label, :type => :text, :name => name, :value => value)
       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 ] ]
+      def form_checkbox(label, name, checked = false)
+        hash = {:type => :checkbox, :name => name}
+        hash[:checked] = 'checked' if checked
+        form_input(label, hash)
+      end
 
-    TIME_GENERIC = [
-      [ :day,   DAYS ],
-      [ :month, MONTHS ],
-      [ :year,  YEARS ],
-      [ :hour,  HOURS ],
-      [ :min,   MINUTES ],
-      [ :sec,   SECONDS ] ]
+      def form_password(label, name)
+        form_input(label, :type => :password, :name => name)
+      end
 
-    # 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
+      def form_textarea(label, name, value = nil)
+        form_build(:textarea, label, :name => name){ value }
       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
+      def form_file(label, name)
+        form_input(label, :type => :file, :name => name)
       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
+      def form_hidden(name, value = nil)
+        Ramaze::Gestalt.build{ input(:type => :hidden, :name => name, :value => value) }
+      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)
+      def form_submit(value = nil)
+        hash = {:type => :submit}.merge(form_tabindex)
+        hash[:value] = value if value
+        Ramaze::Gestalt.build{ tr{ td(:colspan => 2){ input(hash) }}}
+      end
 
-      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)
+      def form_select(label, name, values, hash = {})
+        name = name.to_sym
+        id = "form-#{name}"
+
+        s_args = {:name => name, :id => id}.merge(form_tabindex)
+        s_args[:multiple] = :multiple if hash[:multiple]
+        s_args[:size] = hash[:size] || 1
+
+        has_selected, selected = hash.key?(:selected), hash[:selected]
+        error = form_errors[name.to_s]
+
+        g = Ramaze::Gestalt.new
+        g.tr do
+          g.td do
+            g.label(:for => id){ "#{label}:" }
+            g.span(:class => 'error'){ error } if error
+          end
+          g.td do
+            g.select(s_args) do
+              values.each do |key, value|
+                value ||= key
+                o_args = {:value => value}
+                o_args[:selected] = :selected if has_selected and value == selected
+                g.option(o_args){ key }
+              end
+            end
+          end
         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
+        g.to_s
+      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
+      def form_input(label, hash)
+        form_build(:input, label, hash)
+      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")
+      def form_build(tag_name, label, hash, &block)
+        name = hash[:name].to_sym
+        form_id = "form-#{name}"
+        opts = hash.merge(form_tabindex.merge(:id => form_id))
+        error = form_errors[name.to_s]
+
+        Ramaze::Gestalt.build do
+          tr do
+            td do
+              label(:for => form_id){ "#{label}:" }
+              span(:class => "error"){ error } if error
+            end
+            td do
+              tag(tag_name, opts, &block)
+            end
+          end
         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
+      def form_tabindex
+        @tabindex ||= 0
+        @tabindex += 1
 
-    # <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
-    # returns <input type='text' name='name' value='value' />
-    def field_input(name, value)
-      "<input type='text' name='#{name}' value='#{value}'/>"
-    end
-
-    # returns <textarea name='name'>#{value}</textarea>
-
-    def field_textarea(name, value)
-      "<textarea name='#{name}'>#{value}</textarea>"
-    end
-
-    # returns <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
+        {:tabindex => @tabindex}
       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>" ]
+      def form_error(name, message)
+        form_errors[name.to_s] = message.to_s
       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>" ]
+      def form_errors
+        @form_errors ||= {}
       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)
+      def form_errors_from_model(obj)
+        obj.errors.each do |key, value|
+          form_error(key, value.first % key)
         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,6 +3,34 @@
 
 module Ramaze
   module Helper::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
+    #   numeric_counter(0, 'comment') # => 'no comments'
+    #   numeric_counter(1, 'comment') # => 'one comment'
+    #   numeric_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.
     #
@@ -44,7 +72,7 @@ module Ramaze
     end
 
     # stolen and adapted from rails
-    def time_diff from_time, to_time = Time.now, include_seconds = false
+    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
 
@@ -121,10 +149,9 @@ module Ramaze
     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>)
+    def obfuscate_email(email, text = nil)
+      obfuscated = email.to_s.each_byte.map{|c| "&#%03d" % c}.join
+      %(<a href="mailto:#{obfuscated}">#{text || obfuscated}</a>)
     end
 
     # Returns Hash with tags as keys and their weight as value.

data/lib/ramaze/helper/gestalt.rb

@@ -1,4 +1,4 @@
-require 'gestalt'
+require 'ramaze/gestalt'
 
 module Ramaze
   module Helper

data/lib/ramaze/helper/gravatar.rb

@@ -1,31 +1,78 @@
 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
 
-      # fetches a gravatar from http//www.gravatar.com based on 'email'
-      # and 'size'. Falls back to 'fallback_path' if no gravatar is found.
-      # default 'fallback_path' is "/images/gravatar_default.jpg".
-      # example:
+      # API to build gravatar URIs from an email address (or any other String).
       #
-      # class GravatarController < Ramaze::Controller
-      #    helper :gravatar
+      # @example Simple usage
       #
-      #    def index
-      #      @gravatar_thumbnail_src = gravatar(session[:email] || 'riku@helloit.fi')
-      #    end
-      # end
+      #   class Gravatars < Ramaze::Controller
+      #     helper :gravatar
       #
-      #  /view/gravatar/index.html:
-      #  <img src="#{@gravatar_thumbnail_src}" />
-
-      def gravatar(email, size = 32, fallback_path = "/images/gravatar_default.jpg")
-        emailhash = Digest::MD5.hexdigest(email)
+      #     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}"
 
-        fallback = Request.current.domain
-        fallback.path = fallback_path
-        default = Rack::Utils.escape(fallback.to_s)
+        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]
 
-        return "http://www.gravatar.com/avatar.php?gravatar_id=#{emailhash}&default=#{default}&size=#{size}"
+        uri.query = Rack::Utils.build_query(query) if query.any?
+        uri
       end
     end
   end