padrino-helpers 0.7.5 → 0.7.6

data/VERSION

@@ -1 +1 @@
-0.7.5
+0.7.6

data/lib/padrino-helpers.rb

@@ -7,7 +7,25 @@ Dir[File.dirname(__FILE__) + '/padrino-helpers/**/*.rb'].each {|file| require fi
 I18n.load_path += Dir["#{File.dirname(__FILE__)}/padrino-helpers/locale/*.yml"]
 
 module Padrino
+  ##
+  # This component provides a great deal of view helpers related to html markup generation. 
+  # There are helpers for generating tags, forms, links, images, and more. 
+  # Most of the basic methods should be very familiar to anyone who has used rails view helpers.
+  # 
   module Helpers
+    ##
+    # Register these helpers:
+    # 
+    #   Padrino::Helpers::OutputHelpers
+    #   Padrino::Helpers::TagHelpers
+    #   Padrino::Helpers::AssetTagHelpers
+    #   Padrino::Helpers::FormHelpers
+    #   Padrino::Helpers::FormatHelpers
+    #   Padrino::Helpers::RenderHelpers
+    #   Padrino::Helpers::NumberHelpers
+    # 
+    # for Padrino::Application
+    # 
     def self.registered(app)
       app.set :default_builder, 'StandardFormBuilder'
       app.helpers Padrino::Helpers::OutputHelpers
@@ -16,6 +34,7 @@ module Padrino
       app.helpers Padrino::Helpers::FormHelpers
       app.helpers Padrino::Helpers::FormatHelpers
       app.helpers Padrino::Helpers::RenderHelpers
+      app.helpers Padrino::Helpers::NumberHelpers
     end
-  end
-end
+  end # Helpers
+end # Padrino

data/lib/padrino-helpers/asset_tag_helpers.rb

@@ -1,11 +1,10 @@
 module Padrino
   module Helpers
     module AssetTagHelpers
-
       ##
       # Creates a div to display the flash of given type if it exists
       # 
-      # Examples:
+      # ==== Examples
       # 
       #   flash_tag(:notice, :class => 'flash', :id => 'flash-notice')
       def flash_tag(kind, options={})
@@ -18,7 +17,7 @@ module Padrino
       ##
       # Creates a link element with given name, url and options
       # 
-      # Examples:
+      # ==== Examples
       # 
       #   link_to 'click me', '/dashboard', :class => 'linky'
       #   link_to 'click me', '/dashboard', :if => @foo.present?
@@ -51,7 +50,7 @@ module Padrino
       ##
       # Creates a mail link element with given name and caption
       # 
-      # Examples:
+      # ==== Examples
       #   mail_to "me@demo.com"             => <a href="mailto:me@demo.com">me@demo.com</a>
       #   mail_to "me@demo.com", "My Email" => <a href="mailto:me@demo.com">My Email</a>
       # 
@@ -65,7 +64,7 @@ module Padrino
       ##
       # Creates a meta element with the content and given options
       # 
-      # Examples:
+      # ==== Examples
       # 
       #   meta_tag "weblog,news", :name => "keywords"                         => <meta name="keywords" content="weblog,news">
       #   meta_tag "text/html; charset=UTF-8", :http-equiv => "Content-Type"  => <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
@@ -78,7 +77,7 @@ module Padrino
       ##
       # Creates an image element with given url and options
       # 
-      # Example:
+      # ==== Examples
       # 
       #   image_tag('icons/avatar.png')
       # 
@@ -92,7 +91,7 @@ module Padrino
       # You can pass in the filename without extension or a symbol and we search it in your +appname.public+ 
       # like app/public/stylesheets for inclusion. You can provide also a full path.
       # 
-      # Example:
+      # ==== Examples
       # 
       #   stylesheet_link_tag 'style', 'application', 'layout'
       # 
@@ -106,7 +105,7 @@ module Padrino
       # You can pass in the filename without extension or a symbol and we search it in your +appname.public+ 
       # like app/public/javascript for inclusion. You can provide also a full path.
       # 
-      # Example:
+      # ==== Examples
       # 
       #   javascript_include_tag 'application', :extjs
       # 
@@ -119,7 +118,7 @@ module Padrino
       # Returns the path to the image, either relative or absolute. We search it in your +appname.public+ 
       # like app/public/images for inclusion. You can provide also a full path.
       # 
-      # Example:
+      # ==== Examples
       # 
       #   image_path("foo.jpg") => "yourapp/public/images/foo.jpg" 
       # 
@@ -184,6 +183,6 @@ module Padrino
             true
           end
         end
-    end
-  end
-end
+    end # AssetTagHelpers
+  end # Helpers
+end # Padrino

data/lib/padrino-helpers/form_builder/abstract_form_builder.rb

@@ -1,7 +1,7 @@
 module Padrino
   module Helpers
-    module FormBuilder
-      class AbstractFormBuilder
+    module FormBuilder #:nodoc:
+      class AbstractFormBuilder #:nodoc:
         attr_accessor :template, :object
 
         def initialize(template, object)
@@ -144,7 +144,7 @@ module Padrino
           def object_class(explicit_object)
             explicit_object.is_a?(Symbol) ? explicit_object.to_s.classify.constantize : explicit_object.class
           end
-      end
-    end
-  end
-end
+      end # AbstractFormBuilder
+    end # FormBuilder
+  end # Helpers
+end # Padrino

data/lib/padrino-helpers/form_builder/standard_form_builder.rb

@@ -2,15 +2,18 @@ require File.dirname(__FILE__) + '/abstract_form_builder' unless defined?(Abstra
 
 module Padrino
   module Helpers
-    module FormBuilder
-      class StandardFormBuilder < AbstractFormBuilder
+    module FormBuilder #:nodoc:
+      class StandardFormBuilder < AbstractFormBuilder #:nodoc:
 
-        # text_field_block(:username, { :class => 'long' }, { :class => 'wide-label' })
-        # text_area_block(:summary, { :class => 'long' }, { :class => 'wide-label' })
-        # password_field_block(:password, { :class => 'long' }, { :class => 'wide-label' })
-        # file_field_block(:photo, { :class => 'long' }, { :class => 'wide-label' })
-        # check_box_block(:remember_me, { :class => 'long' }, { :class => 'wide-label' })
-        # select_block(:color, :options => ['green', 'black'])
+        ##
+        # StandardFormBuilder
+        # 
+        #   text_field_block(:username, { :class => 'long' }, { :class => 'wide-label' })
+        #   text_area_block(:summary, { :class => 'long' }, { :class => 'wide-label' })
+        #   password_field_block(:password, { :class => 'long' }, { :class => 'wide-label' })
+        #   file_field_block(:photo, { :class => 'long' }, { :class => 'wide-label' })
+        #   check_box_block(:remember_me, { :class => 'long' }, { :class => 'wide-label' })
+        #   select_block(:color, :options => ['green', 'black'])
         (self.field_types - [ :hidden_field, :radio_button ]).each do |field_type|
           class_eval <<-EOF
           def #{field_type}_block(field, options={}, label_options={})
@@ -33,7 +36,7 @@ module Padrino
           submit_html = self.image_submit(source, options)
           @template.content_tag(:p, submit_html)
         end
-      end
-    end
-  end
-end
+      end # StandardFormBuilder
+    end # FormBuilder
+  end # Helpers
+end # Padrino

data/lib/padrino-helpers/form_helpers.rb

@@ -1,27 +1,42 @@
 module Padrino
   module Helpers
     module FormHelpers
+      ##
       # Constructs a form for object using given or default form_builder
-      # form_for :user, '/register' do |f| ... end
-      # form_for @user, '/register', :id => 'register' do |f| ... end
+      # 
+      # ==== Examples
+      # 
+      #   form_for :user, '/register' do |f| ... end
+      #   form_for @user, '/register', :id => 'register' do |f| ... end
+      # 
       def form_for(object, url, settings={}, &block)
         builder_class = configured_form_builder_class(settings[:builder])
         form_html = capture_html(builder_class.new(self, object), &block)
         form_tag(url, settings) { form_html }
       end
 
+      ##
       # Constructs form fields for an object using given or default form_builder
       # Used within an existing form to allow alternate objects within one form
-      # fields_for @user.assignment do |assignment| ... end
-      # fields_for :assignment do |assigment| ... end
+      # 
+      # ==== Examples
+      # 
+      #   fields_for @user.assignment do |assignment| ... end
+      #   fields_for :assignment do |assigment| ... end
+      # 
       def fields_for(object, settings={}, &block)
         builder_class = configured_form_builder_class(settings[:builder])
         fields_html = capture_html(builder_class.new(self, object), &block)
         concat_content fields_html
       end
 
+      ##
       # Constructs a form without object based on options
-      # form_tag '/register' do ... end
+      # 
+      # ==== Examples
+      #   
+      #   form_tag '/register' do ... end
+      # 
       def form_tag(url, options={}, &block)
         options.reverse_merge!(:method => 'post', :action => url)
         options[:enctype] = "multipart/form-data" if options.delete(:multipart)
@@ -30,9 +45,13 @@ module Padrino
         concat_content content_tag('form', inner_form_html, options)
       end
 
+      ##
       # Constructs a field_set to group fields with given options
-      # field_set_tag("Office", :class => 'office-set')
-      # parameters: legend_text=nil, options={}
+      # 
+      # ==== Examples
+      #   
+      #   field_set_tag("Office", :class => 'office-set')
+      # 
       def field_set_tag(*args, &block)
         options = args.extract_options!
         legend_text = args[0].is_a?(String) ? args.first : nil
@@ -41,8 +60,13 @@ module Padrino
         concat_content content_tag('fieldset', field_set_content, options)
       end
 
+      ##
       # Constructs list html for the errors for a given symbol
-      # error_messages_for :user
+      # 
+      # ==== Examples
+      # 
+      #   error_messages_for :user
+      # 
       def error_messages_for(*params)
         options = params.extract_options!.symbolize_keys
         objects = params.collect {|object_name| object_name.is_a?(Symbol) ? instance_variable_get("@#{object_name}") : object_name }.compact
@@ -84,9 +108,14 @@ module Padrino
         end
       end
 
+      ##
       # Constructs a label tag from the given options
-      # label_tag :username, :class => 'long-label'
-      # label_tag :username, :class => 'long-label' do ... end
+      # 
+      # ==== Examples
+      # 
+      #   label_tag :username, :class => 'long-label'
+      #   label_tag :username, :class => 'long-label' do ... end
+      # 
       def label_tag(name, options={}, &block)
         options.reverse_merge!(:caption => "#{name.to_s.titleize}: ", :for => name)
         caption_text = options.delete(:caption)
@@ -99,39 +128,64 @@ module Padrino
         end
       end
 
+      ##
       # Constructs a hidden field input from the given options
-      # hidden_field_tag :session_key, :value => "__secret__"
+      # 
+      # ==== Examples
+      #   
+      #   hidden_field_tag :session_key, :value => "__secret__"
+      # 
       def hidden_field_tag(name, options={})
         options.reverse_merge!(:name => name)
         input_tag(:hidden, options)
       end
 
+      ##
       # Constructs a text field input from the given options
-      # text_field_tag :username, :class => 'long'
+      # 
+      # ==== Examples
+      # 
+      #   text_field_tag :username, :class => 'long'
+      # 
       def text_field_tag(name, options={})
         options.reverse_merge!(:name => name)
         input_tag(:text, options)
       end
 
+      ##
       # Constructs a text area input from the given options
-      # text_area_tag :username, :class => 'long', :value => "Demo?"
+      # 
+      # ==== Examples
+      # 
+      #   text_area_tag :username, :class => 'long', :value => "Demo?"
+      # 
       def text_area_tag(name, options={})
         options.reverse_merge!(:name => name)
         content_tag(:textarea, options.delete(:value).to_s, options)
       end
 
+      ##
       # Constructs a password field input from the given options
-      # password_field_tag :password, :class => 'long'
+      # 
+      # ==== Examples
+      # 
+      #   password_field_tag :password, :class => 'long'
+      # 
       def password_field_tag(name, options={})
         options.reverse_merge!(:name => name)
         input_tag(:password, options)
       end
 
+      ##
       # Constructs a check_box from the given options
-      # options = [['caption', 'value'], ['Green', 'green1'], ['Blue', 'blue1'], ['Black', "black1"]]
-      # options = ['option', 'red', 'yellow' ]
-      # select_tag(:favorite_color, :options => ['red', 'yellow'], :selected => 'green1')
-      # select_tag(:country, :collection => @countries, :fields => [:name, :code])
+      # 
+      # ==== Examples
+      # 
+      #   options = [['caption', 'value'], ['Green', 'green1'], ['Blue', 'blue1'], ['Black', "black1"]]
+      #   options = ['option', 'red', 'yellow' ]
+      #   select_tag(:favorite_color, :options => ['red', 'yellow'], :selected => 'green1')
+      #   select_tag(:country, :collection => @countries, :fields => [:name, :code])
+      # 
       def select_tag(name, options={})
         options.reverse_merge!(:name => name)
         collection, fields = options.delete(:collection), options.delete(:fields)
@@ -142,43 +196,72 @@ module Padrino
         content_tag(:select, select_options_html, options)
       end
 
+      ##
       # Constructs a check_box from the given options
-      # check_box_tag :remember_me, :value => 'Yes'
+      # 
+      # ==== Examples
+      # 
+      #   check_box_tag :remember_me, :value => 'Yes'
+      # 
       def check_box_tag(name, options={})
         options.reverse_merge!(:name => name, :value => '1')
         input_tag(:checkbox, options)
       end
 
+      ##
       # Constructs a radio_button from the given options
-      # radio_button_tag :remember_me, :value => 'true'
+      # 
+      # ==== Examples
+      # 
+      #   radio_button_tag :remember_me, :value => 'true'
+      # 
       def radio_button_tag(name, options={})
         options.reverse_merge!(:name => name)
         input_tag(:radio, options)
       end
 
+      ##
       # Constructs a file field input from the given options
-      # file_field_tag :photo, :class => 'long'
+      # 
+      # ==== Examples
+      # 
+      #   file_field_tag :photo, :class => 'long'
+      # 
       def file_field_tag(name, options={})
         options.reverse_merge!(:name => name)
         input_tag(:file, options)
       end
 
+      ##
       # Constructs a submit button from the given options
-      # submit_tag "Create", :class => 'success'
+      # 
+      # ==== Examples
+      # 
+      #   submit_tag "Create", :class => 'success'
+      # 
       def submit_tag(caption="Submit", options={})
         options.reverse_merge!(:value => caption)
         input_tag(:submit, options)
       end
 
+      ##
       # Constructs a button input from the given options
-      # button_tag "Cancel", :class => 'clear'
+      # 
+      # ==== Examples
+      # 
+      #   button_tag "Cancel", :class => 'clear'
+      # 
       def button_tag(caption, options = {})
         options.reverse_merge!(:value => caption)
         input_tag(:button, options)
       end
 
       # Constructs a submit button from the given options
-      # submit_tag "Create", :class => 'success'
+      # 
+      # ==== Examples
+      # 
+      #   submit_tag "Create", :class => 'success'
+      # 
       def image_submit_tag(source, options={})
         options.reverse_merge!(:src => image_path(source))
         input_tag(:image, options)
@@ -221,6 +304,6 @@ module Padrino
           configured_builder = "Padrino::Helpers::FormBuilder::#{configured_builder}".constantize if configured_builder.is_a?(String)
           configured_builder
         end
-    end
-  end
-end
+    end # FormHelpers
+  end # Helpers
+end # Padrino

data/lib/padrino-helpers/format_helpers.rb

@@ -1,25 +1,33 @@
 module Padrino
   module Helpers
     module FormatHelpers
-
+      ## 
       # Returns escaped text to protect against malicious content
+      # 
       def escape_html(text)
         Rack::Utils.escape_html(text)
       end
       alias h escape_html
       alias sanitize_html escape_html
 
+      ##
       # Returns escaped text to protect against malicious content
       # Returns blank if the text is empty
+      # 
       def h!(text, blank_text = ' ')
         return blank_text if text.nil? || text.empty?
         h text
       end
 
+      ##
       # Returns text transformed into HTML using simple formatting rules. Two or more consecutive newlines(\n\n) are considered
       # as a paragraph and wrapped in <p> tags. One newline (\n) is considered as a linebreak and a <br /> tag is appended.
       # This method does not remove the newlines from the text.
-      # simple_format("hello\nworld") # => "<p>hello<br/>world</p>"
+      # 
+      # ==== Examples
+      # 
+      #   simple_format("hello\nworld") # => "<p>hello<br/>world</p>"
+      # 
       def simple_format(text, html_options={})
         start_tag = tag('p', html_options.merge(:open => true))
         text = text.to_s.dup
@@ -30,16 +38,26 @@ module Padrino
         text << "</p>"
       end
 
+      ##
       # Attempts to pluralize the singular word unless count is 1. If plural is supplied, it will use that when count is > 1,
       # otherwise it will use the Inflector to determine the plural form
-      # pluralize(2, 'person') => '2 people'
+      # 
+      # ==== Examples
+      # 
+      #   pluralize(2, 'person') => '2 people'
+      # 
       def pluralize(count, singular, plural = nil)
         "#{count || 0} " + ((count == 1 || count == '1') ? singular : (plural || singular.pluralize))
       end
 
+      ##
       # Truncates a given text after a given :length if text is longer than :length (defaults to 30).
       # The last characters will be replaced with the :omission (defaults to "…") for a total length not exceeding :length.
-      # truncate("Once upon a time in a world far far away", :length => 8) => "Once upon..."
+      # 
+      # ==== Examples
+      # 
+      #   truncate("Once upon a time in a world far far away", :length => 8) => "Once upon..."
+      # 
       def truncate(text, *args)
         options = args.extract_options!
         options.reverse_merge!(:length => 30, :omission => "...")
@@ -50,9 +68,14 @@ module Padrino
         end
       end
 
+      ##
       # Wraps the text into lines no longer than line_width width.
       # This method breaks on the first whitespace character that does not exceed line_width (which is 80 by default).
-      # word_wrap('Once upon a time', :line_width => 8) => "Once upon\na time"
+      # 
+      # ==== Examples
+      # 
+      #   word_wrap('Once upon a time', :line_width => 8) => "Once upon\na time"
+      # 
       def word_wrap(text, *args)
         options = args.extract_options!
         unless args.blank?
@@ -65,6 +88,7 @@ module Padrino
         end * "\n"
       end
 
+      ##
       # Reports the approximate distance in time between two Time or Date objects or integers as seconds.
       # Set <tt>include_seconds</tt> to true if you want more detailed approximations when distance < 1 min, 29 secs
       # Distances are reported based on the following table:
@@ -92,6 +116,7 @@ module Padrino
       #   60-89 secs      # => 1 minute
       #
       # ==== Examples
+      # 
       #   from_time = Time.now
       #   distance_of_time_in_words(from_time, from_time + 50.minutes)        # => about 1 hour
       #   distance_of_time_in_words(from_time, 50.minutes.from_now)           # => about 1 hour
@@ -155,20 +180,24 @@ module Padrino
         end
       end
 
+      ##
       # Like distance_of_time_in_words, but where <tt>to_time</tt> is fixed to <tt>Time.now</tt>.
       #
       # ==== Examples
+      # 
       #   time_ago_in_words(3.minutes.from_now)       # => 3 minutes
       #   time_ago_in_words(Time.now - 15.hours)      # => 15 hours
       #   time_ago_in_words(Time.now)                 # => less than a minute
       #
       #   from_time = Time.now - 3.days - 14.minutes - 25.seconds     # => 3 days
+      # 
       def time_ago_in_words(from_time, include_seconds = false)
         distance_of_time_in_words(from_time, Time.now, include_seconds)
       end
 
-      # Used in xxxx.js.erb files to escape html so that it can be passed to javascript from Padrino
-      # js_escape_html("<h1>Hey</h1>")
+      ##
+      # Remove unsafe chars from our javascript
+      # 
       def escape_javascript(html_content)
         return '' unless html_content
         javascript_mapping = { '\\' => '\\\\', '</' => '<\/', "\r\n" => '\n', "\n" => '\n' }
@@ -177,10 +206,14 @@ module Padrino
         escaped_string
       end
 
+      ##
+      # Used in xxxx.js.erb files to escape html so that it can be passed to javascript from Padrino
+      # 
+      #   js_escape_html("<h1>Hey</h1>")
+      # 
       def js_escape_html(html_content)
         "\"#{escape_javascript(html_content)}\""
       end
-
-    end
-  end
-end
+    end # FormatHelpers
+  end # Helpers
+end # Padrino

data/lib/padrino-helpers/number_helpers.rb

@@ -0,0 +1,271 @@
+require 'bigdecimal'
+
+module Padrino
+  module Helpers
+    ##
+    # Provides methods for converting numbers into formatted strings.
+    # Methods are provided for phone numbers, currency, percentage,
+    # precision, positional notation, and file size.
+    # 
+    # Verbatim copy of Rails Number helper
+    # 
+    module NumberHelpers
+      ##
+      # Formats a +number+ into a currency string (e.g., $13.65). You can customize the format
+      # in the +options+ hash.
+      #
+      # ==== Options
+      # * <tt>:precision</tt>  -  Sets the level of precision (defaults to 2).
+      # * <tt>:unit</tt>       - Sets the denomination of the currency (defaults to "$").
+      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to ",").
+      # * <tt>:format</tt>     - Sets the format of the output string (defaults to "%u%n"). The field types are:
+      #
+      #     %u  The currency unit
+      #     %n  The number
+      #
+      # ==== Examples
+      # 
+      #   number_to_currency(1234567890.50)                    # => $1,234,567,890.50
+      #   number_to_currency(1234567890.506)                   # => $1,234,567,890.51
+      #   number_to_currency(1234567890.506, :precision => 3)  # => $1,234,567,890.506
+      #   
+      #   number_to_currency(1234567890.50, :unit => "&pound;", :separator => ",", :delimiter => "")
+      #   # => &pound;1234567890,50
+      #   number_to_currency(1234567890.50, :unit => "&pound;", :separator => ",", :delimiter => "", :format => "%n %u")
+      #   # => 1234567890,50 &pound;
+      # 
+      def number_to_currency(number, options = {})
+        options.symbolize_keys!
+
+        defaults  = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+        currency  = I18n.translate(:'number.currency.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults  = defaults.merge(currency)
+
+        precision = options[:precision] || defaults[:precision]
+        unit      = options[:unit]      || defaults[:unit]
+        separator = options[:separator] || defaults[:separator]
+        delimiter = options[:delimiter] || defaults[:delimiter]
+        format    = options[:format]    || defaults[:format]
+        separator = '' if precision == 0
+
+        begin
+          format.gsub(/%n/, number_with_precision(number,
+            :precision => precision,
+            :delimiter => delimiter,
+            :separator => separator)
+          ).gsub(/%u/, unit)
+        rescue
+          number
+        end
+      end
+
+      ##
+      # Formats a +number+ as a percentage string (e.g., 65%). You can customize the
+      # format in the +options+ hash.
+      #
+      # ==== Options
+      # * <tt>:precision</tt>  - Sets the level of precision (defaults to 3).
+      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
+      #
+      # ==== Examples
+      # 
+      #   number_to_percentage(100)                                        # => 100.000%
+      #   number_to_percentage(100, :precision => 0)                       # => 100%
+      #   number_to_percentage(1000, :delimiter => '.', :separator => ',') # => 1.000,000%
+      #   number_to_percentage(302.24398923423, :precision => 5)           # => 302.24399%
+      # 
+      def number_to_percentage(number, options = {})
+        options.symbolize_keys!
+
+        defaults   = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+        percentage = I18n.translate(:'number.percentage.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults  = defaults.merge(percentage)
+
+        precision = options[:precision] || defaults[:precision]
+        separator = options[:separator] || defaults[:separator]
+        delimiter = options[:delimiter] || defaults[:delimiter]
+
+        begin
+          number_with_precision(number,
+            :precision => precision,
+            :separator => separator,
+            :delimiter => delimiter) + "%"
+        rescue
+          number
+        end
+      end
+
+      ##
+      # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324). You can
+      # customize the format in the +options+ hash.
+      #
+      # ==== Options
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to ",").
+      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      #
+      # ==== Examples
+      # 
+      #   number_with_delimiter(12345678)                        # => 12,345,678
+      #   number_with_delimiter(12345678.05)                     # => 12,345,678.05
+      #   number_with_delimiter(12345678, :delimiter => ".")     # => 12.345.678
+      #   number_with_delimiter(12345678, :separator => ",")     # => 12,345,678
+      #   number_with_delimiter(98765432.98, :delimiter => " ", :separator => ",")
+      #   # => 98 765 432,98
+      #
+      # You can still use <tt>number_with_delimiter</tt> with the old API that accepts the
+      # +delimiter+ as its optional second and the +separator+ as its
+      # optional third parameter:
+      # 
+      #   number_with_delimiter(12345678, " ")                     # => 12 345.678
+      #   number_with_delimiter(12345678.05, ".", ",")             # => 12.345.678,05
+      # 
+      def number_with_delimiter(number, *args)
+        options = args.extract_options!
+        options.symbolize_keys!
+
+        defaults = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+
+        delimiter ||= (options[:delimiter] || defaults[:delimiter])
+        separator ||= (options[:separator] || defaults[:separator])
+
+        begin
+          parts = number.to_s.split('.')
+          parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+          parts.join(separator)
+        rescue
+          number
+        end
+      end
+
+      ##
+      # Formats a +number+ with the specified level of <tt>:precision</tt> (e.g., 112.32 has a precision of 2).
+      # You can customize the format in the +options+ hash.
+      #
+      # ==== Options
+      # 
+      # * <tt>:precision</tt>  - Sets the level of precision (defaults to 3).
+      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
+      #
+      # ==== Examples
+      # 
+      #   number_with_precision(111.2345)                    # => 111.235
+      #   number_with_precision(111.2345, :precision => 2)   # => 111.23
+      #   number_with_precision(13, :precision => 5)         # => 13.00000
+      #   number_with_precision(389.32314, :precision => 0)  # => 389
+      #   number_with_precision(1111.2345, :precision => 2, :separator => ',', :delimiter => '.')
+      #   # => 1.111,23
+      #
+      # You can still use <tt>number_with_precision</tt> with the old API that accepts the
+      # +precision+ as its optional second parameter:
+      #   
+      #   number_with_precision(number_with_precision(111.2345, 2)   # => 111.23
+      # 
+      def number_with_precision(number, *args)
+        options = args.extract_options!
+        options.symbolize_keys!
+
+        defaults           = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+        precision_defaults = I18n.translate(:'number.precision.format', :locale => options[:locale],
+                                                                        :raise => true) rescue {}
+        defaults           = defaults.merge(precision_defaults)
+
+        precision ||= (options[:precision] || defaults[:precision])
+        separator ||= (options[:separator] || defaults[:separator])
+        delimiter ||= (options[:delimiter] || defaults[:delimiter])
+
+        begin
+          rounded_number = BigDecimal.new((Float(number) * (10 ** precision)).to_s).round.to_f / 10 ** precision
+          number_with_delimiter("%01.#{precision}f" % rounded_number,
+            :separator => separator,
+            :delimiter => delimiter)
+        rescue
+          number
+        end
+      end
+
+      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb].freeze
+
+      ##
+      # Formats the bytes in +size+ into a more understandable representation
+      # (e.g., giving it 1500 yields 1.5 KB). This method is useful for
+      # reporting file sizes to users. This method returns nil if
+      # +size+ cannot be converted into a number. You can customize the
+      # format in the +options+ hash.
+      #
+      # ==== Options
+      # * <tt>:precision</tt>  - Sets the level of precision (defaults to 1).
+      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
+      #
+      # ==== Examples
+      # 
+      #   number_to_human_size(123)                                          # => 123 Bytes
+      #   number_to_human_size(1234)                                         # => 1.2 KB
+      #   number_to_human_size(12345)                                        # => 12.1 KB
+      #   number_to_human_size(1234567)                                      # => 1.2 MB
+      #   number_to_human_size(1234567890)                                   # => 1.1 GB
+      #   number_to_human_size(1234567890123)                                # => 1.1 TB
+      #   number_to_human_size(1234567, :precision => 2)                     # => 1.18 MB
+      #   number_to_human_size(483989, :precision => 0)                      # => 473 KB
+      #   number_to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,18 MB
+      #
+      # Zeros after the decimal point are always stripped out, regardless of the
+      # specified precision:
+      #   
+      #   helper.number_to_human_size(1234567890123, :precision => 5)        # => "1.12283 TB"
+      #   helper.number_to_human_size(524288000, :precision=>5)              # => "500 MB"
+      #
+      # You can still use <tt>number_to_human_size</tt> with the old API that accepts the
+      # +precision+ as its optional second parameter:
+      # 
+      #   number_to_human_size(1234567, 2)    # => 1.18 MB
+      #   number_to_human_size(483989, 0)     # => 473 KB
+      # 
+      def number_to_human_size(number, *args)
+        return nil if number.nil?
+
+        options = args.extract_options!
+        options.symbolize_keys!
+
+        defaults = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+        human    = I18n.translate(:'number.human.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults = defaults.merge(human)
+
+        precision ||= (options[:precision] || defaults[:precision])
+        separator ||= (options[:separator] || defaults[:separator])
+        delimiter ||= (options[:delimiter] || defaults[:delimiter])
+
+        storage_units_format = I18n.translate(:'number.human.storage_units.format', :locale => options[:locale], :raise => true)
+
+        if number.to_i < 1024
+          unit = I18n.translate(:'number.human.storage_units.units.byte', :locale => options[:locale], :count => number.to_i, :raise => true)
+          storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, unit)
+        else
+          max_exp  = STORAGE_UNITS.size - 1
+          number   = Float(number)
+          exponent = (Math.log(number) / Math.log(1024)).to_i # Convert to base 1024
+          exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
+          number  /= 1024 ** exponent
+
+          unit_key = STORAGE_UNITS[exponent]
+          unit = I18n.translate(:"number.human.storage_units.units.#{unit_key}", :locale => options[:locale], :count => number, :raise => true)
+
+          begin
+            escaped_separator = Regexp.escape(separator)
+            formatted_number = number_with_precision(number,
+              :precision => precision,
+              :separator => separator,
+              :delimiter => delimiter
+            ).sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+            storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
+          rescue
+            number
+          end
+        end
+      end
+    end # NumberHelpers
+  end # Helpers
+end # Padrino

data/lib/padrino-helpers/output_helpers.rb

@@ -1,8 +1,13 @@
 module Padrino
   module Helpers
     module OutputHelpers
+      ##
       # Captures the html from a block of template code for erb or haml
-      # capture_html(&block) => "...html..."
+      # 
+      # ==== Examples
+      # 
+      #   capture_html(&block) => "...html..."
+      # 
       def capture_html(*args, &block)
         if self.respond_to?(:is_haml?) && is_haml?
           block_is_haml?(block) ? capture_haml(*args, &block) : block.call
@@ -14,8 +19,13 @@ module Padrino
         end
       end
 
+      ##
       # Outputs the given text to the templates buffer directly
-      # concat_content("This will be output to the template buffer in erb or haml")
+      # 
+      # ==== Examples
+      # 
+      #   concat_content("This will be output to the template buffer in erb or haml")
+      # 
       def concat_content(text="")
         if self.respond_to?(:is_haml?) && is_haml?
           haml_concat(text)
@@ -26,26 +36,41 @@ module Padrino
         end
       end
 
+      ##
       # Returns true if the block is from an ERB or HAML template; false otherwise.
       # Used to determine if html should be returned or concatted to view
-      # block_is_template?(block)
+      # 
+      # ==== Examples
+      # 
+      #   block_is_template?(block)
+      # 
       def block_is_template?(block)
         block && (block_is_erb?(block) || (self.respond_to?(:block_is_haml?) && block_is_haml?(block)))
       end
 
+      ##
       # Capture a block of content to be rendered at a later time.
       # Your blocks can also receive values, which are passed to them by <tt>yield_content</tt>
-      # content_for(:name) { ...content... }
-      # content_for(:name) { |name| ...content... }
+      # 
+      # ==== Examples
+      # 
+      #   content_for(:name) { ...content... }
+      #   content_for(:name) { |name| ...content... }
+      # 
       def content_for(key, &block)
         content_blocks[key.to_sym] << block
       end
 
+      ##
       # Render the captured content blocks for a given key.
       # You can also pass values to the content blocks by passing them
       # as arguments after the key.
-      # yield_content :include
-      # yield_content :head, "param1", "param2"
+      # 
+      # ==== Examples
+      # 
+      #   yield_content :include
+      #   yield_content :head, "param1", "param2"
+      # 
       def yield_content(key, *args)
         content_blocks[key.to_sym].map { |content|
           capture_html(*args, &content)
@@ -92,6 +117,6 @@ module Padrino
         ensure
           @_out_buf = old_buffer
         end
-    end
-  end
-end
+    end # OutputHelpers
+  end # Helpers
+end # Padrino

data/lib/padrino-helpers/render_helpers.rb

@@ -1,9 +1,14 @@
 module Padrino
   module Helpers
     module RenderHelpers
+      ##
       # Partials implementation which includes collections support
-      # partial 'photo/_item', :object => @photo
-      # partial 'photo/_item', :collection => @photos
+      # 
+      # ==== Examples
+      # 
+      #   partial 'photo/_item', :object => @photo
+      #   partial 'photo/_item', :collection => @photos
+      # 
       def partial(template, options={})
         options.reverse_merge!(:locals => {}, :layout => false)
         path = template.to_s.split(File::SEPARATOR)
@@ -27,6 +32,6 @@ module Padrino
         end
       end
       alias :render_partial :partial
-    end
-  end
-end
+    end # RenderHelpers
+  end # Helpers
+end # Padrino

data/lib/padrino-helpers/tag_helpers.rb

@@ -1,17 +1,27 @@
 module Padrino
   module Helpers
     module TagHelpers
+      ##
       # Creates an html input field with given type and options
-      # input_tag :text, :class => "test"
+      # 
+      # ==== Examples
+      # 
+      #   input_tag :text, :class => "test"
+      # 
       def input_tag(type, options = {})
         options.reverse_merge!(:type => type)
         tag(:input, options)
       end
 
+      ##
       # Creates an html tag with given name, content and options
-      # content_tag(:p, "hello", :class => 'light')
-      # content_tag(:p, :class => 'dark') do ... end
-      # parameters: content_tag(name, content=nil, options={}, &block)
+      # 
+      # ==== Examples
+      # 
+      #   content_tag(:p, "hello", :class => 'light')
+      #   content_tag(:p, :class => 'dark') do ... end
+      #   content_tag(name, content=nil, options={}, &block)
+      # 
       def content_tag(*args, &block)
         name = args.first
         options = args.extract_options!
@@ -20,9 +30,14 @@ module Padrino
         block_is_template?(block) ? concat_content(tag_result) : tag_result
       end
 
+      ##
       # Creates an html tag with the given name and options
-      # tag(:br, :style => 'clear:both')
-      # tag(:p, :content => "hello", :class => 'large')
+      # 
+      # ==== Examples
+      # 
+      #   tag(:br, :style => 'clear:both')
+      #   tag(:p, :content => "hello", :class => 'large')
+      # 
       def tag(name, options={})
         content, open_tag = options.delete(:content), options.delete(:open)
         identity_tag_attributes.each { |attr| options[attr] = attr.to_s if options[attr]  }
@@ -36,6 +51,6 @@ module Padrino
         def identity_tag_attributes
           [:checked, :disabled, :selected, :multiple]
         end
-    end
-  end
-end
+    end # TagHelpers
+  end # Helpers
+end # Padrino

data/padrino-helpers.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{padrino-helpers}
-  s.version = "0.7.5"
+  s.version = "0.7.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
-  s.date = %q{2010-02-09}
+  s.date = %q{2010-02-10}
   s.description = %q{Tag helpers, asset helpers, form helpers, form builders and many more helpers for padrino}
   s.email = %q{padrinorb@gmail.com}
   s.extra_rdoc_files = [
@@ -29,6 +29,7 @@ Gem::Specification.new do |s|
      "lib/padrino-helpers/form_helpers.rb",
      "lib/padrino-helpers/format_helpers.rb",
      "lib/padrino-helpers/locale/en.yml",
+     "lib/padrino-helpers/number_helpers.rb",
      "lib/padrino-helpers/output_helpers.rb",
      "lib/padrino-helpers/render_helpers.rb",
      "lib/padrino-helpers/tag_helpers.rb",
@@ -64,6 +65,7 @@ Gem::Specification.new do |s|
      "test/test_form_builder.rb",
      "test/test_form_helpers.rb",
      "test/test_format_helpers.rb",
+     "test/test_number_helpers.rb",
      "test/test_output_helpers.rb",
      "test/test_render_helpers.rb",
      "test/test_tag_helpers.rb"
@@ -81,7 +83,7 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<sinatra>, [">= 0.9.2"])
-      s.add_runtime_dependency(%q<padrino-core>, ["= 0.7.5"])
+      s.add_runtime_dependency(%q<padrino-core>, ["= 0.7.6"])
       s.add_development_dependency(%q<haml>, [">= 2.2.1"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<mocha>, [">= 0.9.7"])
@@ -89,7 +91,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<webrat>, [">= 0.5.1"])
     else
       s.add_dependency(%q<sinatra>, [">= 0.9.2"])
-      s.add_dependency(%q<padrino-core>, ["= 0.7.5"])
+      s.add_dependency(%q<padrino-core>, ["= 0.7.6"])
       s.add_dependency(%q<haml>, [">= 2.2.1"])
       s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<mocha>, [">= 0.9.7"])
@@ -98,7 +100,7 @@ Gem::Specification.new do |s|
     end
   else
     s.add_dependency(%q<sinatra>, [">= 0.9.2"])
-    s.add_dependency(%q<padrino-core>, ["= 0.7.5"])
+    s.add_dependency(%q<padrino-core>, ["= 0.7.6"])
     s.add_dependency(%q<haml>, [">= 2.2.1"])
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<mocha>, [">= 0.9.7"])

data/test/helper.rb

@@ -5,6 +5,8 @@ require 'mocha'
 require 'rack/test'
 require 'webrat'
 
+# require 'extlib' # test with extlib
+
 # We try to load the vendored padrino-core if exist
 %w(core).each do |gem|
   if File.exist?(File.dirname(__FILE__) + "/../../padrino-#{gem}/lib")

data/test/support_helpers.rb

@@ -1,6 +1,5 @@
 require 'padrino-core/support_lite'
 unless Fixnum.method_defined?(:days)
-  # We don't add active_support/core_ext/object/misc because override some extlib defaults
   if Padrino.support == :extlib
     class Object
       # A duck-type assistant method. For example, Active Support extends Date

data/test/test_number_helpers.rb

@@ -0,0 +1,136 @@
+class TestNumberHelpers < Test::Unit::TestCase
+  include Padrino::Helpers::NumberHelpers
+
+  def kilobytes(number)
+    number * 1024
+  end
+
+  def megabytes(number)
+    kilobytes(number) * 1024
+  end
+
+  def gigabytes(number)
+    megabytes(number) * 1024
+  end
+
+  def terabytes(number)
+    gigabytes(number) * 1024
+  end
+
+  context 'for number helpers functionality' do
+
+    should 'display number_to_currency' do
+      assert_equal "$1,234,567,890.50",        number_to_currency(1234567890.50)
+      assert_equal "$1,234,567,890.51",        number_to_currency(1234567890.506)
+      assert_equal "$1,234,567,892",           number_to_currency(1234567891.50, {:precision => 0})
+      assert_equal "$1,234,567,890.5",         number_to_currency(1234567890.50, {:precision => 1})
+      assert_equal "&pound;1234567890,50",     number_to_currency(1234567890.50, {:unit => "&pound;", :separator => ",", :delimiter => ""})
+      assert_equal "$1,234,567,890.50",        number_to_currency("1234567890.50")
+      assert_equal "1,234,567,890.50 K&#269;", number_to_currency("1234567890.50", {:unit => "K&#269;", :format => "%n %u"})
+      assert_equal "$x",                       number_to_currency("x")
+
+      assert_nil number_to_currency(nil)
+    end
+
+    should 'display  number_to_percentage' do
+      assert_equal "100.000%",   number_to_percentage(100)
+      assert_equal "100%",       number_to_percentage(100, {:precision => 0})
+      assert_equal "302.06%",    number_to_percentage(302.0574, {:precision => 2})
+      assert_equal "100.000%",   number_to_percentage("100")
+      assert_equal "1000.000%",  number_to_percentage("1000")
+      assert_equal "x%",         number_to_percentage("x")
+      assert_equal "1.000,000%", number_to_percentage(1000, :delimiter => '.', :separator => ',')
+
+      assert_nil number_to_percentage(nil)
+    end
+
+    should 'display  number_with_delimiter' do
+      assert_equal "12,345,678",        number_with_delimiter(12345678)
+      assert_equal "0",                 number_with_delimiter(0)
+      assert_equal "123",               number_with_delimiter(123)
+      assert_equal "123,456",           number_with_delimiter(123456)
+      assert_equal "123,456.78",        number_with_delimiter(123456.78)
+      assert_equal "123,456.789",       number_with_delimiter(123456.789)
+      assert_equal "123,456.78901",     number_with_delimiter(123456.78901)
+      assert_equal "123,456,789.78901", number_with_delimiter(123456789.78901)
+      assert_equal "0.78901",           number_with_delimiter(0.78901)
+      assert_equal "123,456.78",        number_with_delimiter("123456.78")
+      assert_equal "x",                 number_with_delimiter("x")
+
+      assert_nil number_with_delimiter(nil)
+    end
+
+    should 'display number_with_delimiter with options' do
+      assert_equal '12 345 678',    number_with_delimiter(12345678, :delimiter => ' ')
+      assert_equal '12,345,678-05', number_with_delimiter(12345678.05, :separator => '-')
+      assert_equal '12.345.678,05', number_with_delimiter(12345678.05, :separator => ',', :delimiter => '.')
+      assert_equal '12.345.678,05', number_with_delimiter(12345678.05, :delimiter => '.', :separator => ',')
+    end
+
+    should 'display number_with_precision' do
+      assert_equal "111.235",    number_with_precision(111.2346)
+      assert_equal "31.83",      number_with_precision(31.825, :precision => 2)
+      assert_equal "111.23",     number_with_precision(111.2346, :precision => 2)
+      assert_equal "111.00",     number_with_precision(111, :precision => 2)
+      assert_equal "111.235",    number_with_precision("111.2346")
+      assert_equal "31.83",      number_with_precision("31.825", :precision => 2)
+      assert_equal "3268",       number_with_precision((32.6751 * 100.00), :precision => 0)
+      assert_equal "112",        number_with_precision(111.50, :precision => 0)
+      assert_equal "1234567892", number_with_precision(1234567891.50, :precision => 0)
+
+      # Return non-numeric params unchanged.
+      assert_equal "x", number_with_precision("x")
+      assert_nil number_with_precision(nil)
+    end
+
+    should 'display number_with_precision with custom delimiter and separator' do
+      assert_equal '31,83',     number_with_precision(31.825, :precision => 2, :separator => ',')
+      assert_equal '1.231,83',  number_with_precision(1231.825, :precision => 2, :separator => ',', :delimiter => '.')
+    end
+
+    should 'display number_to_human_size' do
+      assert_equal '0 Bytes',   number_to_human_size(0)
+      assert_equal '1 Byte',    number_to_human_size(1)
+      assert_equal '3 Bytes',   number_to_human_size(3.14159265)
+      assert_equal '123 Bytes', number_to_human_size(123.0)
+      assert_equal '123 Bytes', number_to_human_size(123)
+      assert_equal '1.2 KB',    number_to_human_size(1234)
+      assert_equal '12.1 KB',   number_to_human_size(12345)
+      assert_equal '1.2 MB',    number_to_human_size(1234567)
+      assert_equal '1.1 GB',    number_to_human_size(1234567890)
+      assert_equal '1.1 TB',    number_to_human_size(1234567890123)
+      assert_equal '1025 TB',   number_to_human_size(terabytes(1025))
+      assert_equal '444 KB',    number_to_human_size(kilobytes(444))
+      assert_equal '1023 MB',   number_to_human_size(megabytes(1023))
+      assert_equal '3 TB',      number_to_human_size(terabytes(3))
+      assert_equal '1.18 MB',   number_to_human_size(1234567, :precision => 2)
+      assert_equal '3 Bytes',   number_to_human_size(3.14159265, :precision => 4)
+      assert_equal '123 Bytes', number_to_human_size("123")
+      assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0123), :precision => 2)
+      assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0100), :precision => 4)
+      assert_equal '10 KB',     number_to_human_size(kilobytes(10.000), :precision => 4)
+      assert_equal '1 Byte',    number_to_human_size(1.1)
+      assert_equal '10 Bytes',  number_to_human_size(10)
+
+      assert_nil number_to_human_size(nil)
+    end
+
+    should 'display number_to_human_size with options' do
+      assert_equal '1.18 MB', number_to_human_size(1234567, :precision => 2)
+      assert_equal '3 Bytes', number_to_human_size(3.14159265, :precision => 4)
+      assert_equal '1.01 KB', number_to_human_size(kilobytes(1.0123), :precision => 2)
+      assert_equal '1.01 KB', number_to_human_size(kilobytes(1.0100), :precision => 4)
+      assert_equal '10 KB',   number_to_human_size(kilobytes(10.000), :precision => 4)
+      assert_equal '1 TB',    number_to_human_size(1234567890123, :precision => 0)
+      assert_equal '500 MB',  number_to_human_size(524288000, :precision => 0)
+      assert_equal '40 KB',   number_to_human_size(41010, :precision => 0)
+      assert_equal '40 KB',   number_to_human_size(41100, :precision => 0)
+    end
+
+    should 'display number_to_human_size with custom delimiter and separator' do
+      assert_equal '1,01 KB',     number_to_human_size(kilobytes(1.0123), :precision => 2, :separator => ',')
+      assert_equal '1,01 KB',     number_to_human_size(kilobytes(1.0100), :precision => 4, :separator => ',')
+      assert_equal '1.000,1 TB',  number_to_human_size(terabytes(1000.1), :delimiter => '.', :separator => ',')
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-helpers
 version: !ruby/object:Gem::Version 
-  version: 0.7.5
+  version: 0.7.6
 platform: ruby
 authors: 
 - Padrino Team
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-09 00:00:00 +01:00
+date: 2010-02-10 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -33,7 +33,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.7.5
+        version: 0.7.6
     version: 
 - !ruby/object:Gem::Dependency 
   name: haml
@@ -107,6 +107,7 @@ files:
 - lib/padrino-helpers/form_helpers.rb
 - lib/padrino-helpers/format_helpers.rb
 - lib/padrino-helpers/locale/en.yml
+- lib/padrino-helpers/number_helpers.rb
 - lib/padrino-helpers/output_helpers.rb
 - lib/padrino-helpers/render_helpers.rb
 - lib/padrino-helpers/tag_helpers.rb
@@ -142,6 +143,7 @@ files:
 - test/test_form_builder.rb
 - test/test_form_helpers.rb
 - test/test_format_helpers.rb
+- test/test_number_helpers.rb
 - test/test_output_helpers.rb
 - test/test_render_helpers.rb
 - test/test_tag_helpers.rb