padrino-helpers 0.2.9 → 0.4.5

data/Rakefile

@@ -26,7 +26,7 @@ end
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
+  test.libs << 'test'
   test.pattern = 'test/**/test_*.rb'
   test.verbose = true
 end

data/VERSION

@@ -1 +1 @@
-0.2.9
+0.4.5

data/lib/padrino-helpers.rb

@@ -1,6 +1,9 @@
 require 'padrino-core/support_lite'
 Dir[File.dirname(__FILE__) + '/padrino-helpers/**/*.rb'].each {|file| require file }
 
+# Load our locales
+I18n.load_path += Dir["#{File.dirname(__FILE__)}/padrino-helpers/locale/*.yml"]
+
 module Padrino
   module Helpers
     def self.registered(app)

data/lib/padrino-helpers/asset_tag_helpers.rb

@@ -45,7 +45,7 @@ module Padrino
       # meta_tag "text/html; charset=UTF-8", :http-equiv => "Content-Type"  => <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
       def meta_tag(content, options={})
         options.reverse_merge!("content" => content)
-        content_tag(:meta, '', options)
+        tag(:meta, options)
       end
 
       # Creates an image element with given url and options

data/lib/padrino-helpers/form_helpers.rb

@@ -174,8 +174,8 @@ module Padrino
       # 'put' and 'delete' are just specified using hidden fields with form action still 'put'.
       # hidden_form_method_field('delete') => <input name="_method" value="delete" />
       def hidden_form_method_field(desired_method)
-        return '' if (desired_method =~ /get|post/)
-        original_method = desired_method.dup
+        return '' if (desired_method.to_s =~ /get|post/)
+        original_method = desired_method.to_s.dup
         desired_method.replace('post')
         hidden_field_tag(:_method, :value => original_method)
       end

data/lib/padrino-helpers/format_helpers.rb

@@ -65,42 +65,106 @@ module Padrino
         end * "\n"
       end
 
-      # Smart time helper which returns relative text representing times for recent dates
-      # and absolutes for dates that are far removed from the current date
-      # time_in_words(10.days.ago) => '10 days ago'
-      def time_in_words(date)
-        date = date.to_date
-        date = Date.parse(date, true) unless /Date.*/ =~ date.class.to_s
-        days = (date - Date.today).to_i
+      # 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:
+      #
+      #   0 <-> 29 secs                                                             # => less than a minute
+      #   30 secs <-> 1 min, 29 secs                                                # => 1 minute
+      #   1 min, 30 secs <-> 44 mins, 29 secs                                       # => [2..44] minutes
+      #   44 mins, 30 secs <-> 89 mins, 29 secs                                     # => about 1 hour
+      #   89 mins, 29 secs <-> 23 hrs, 59 mins, 29 secs                             # => about [2..24] hours
+      #   23 hrs, 59 mins, 29 secs <-> 47 hrs, 59 mins, 29 secs                     # => 1 day
+      #   47 hrs, 59 mins, 29 secs <-> 29 days, 23 hrs, 59 mins, 29 secs            # => [2..29] days
+      #   29 days, 23 hrs, 59 mins, 30 secs <-> 59 days, 23 hrs, 59 mins, 29 secs   # => about 1 month
+      #   59 days, 23 hrs, 59 mins, 30 secs <-> 1 yr minus 1 sec                    # => [2..12] months
+      #   1 yr <-> 1 yr, 3 months                                                   # => about 1 year
+      #   1 yr, 3 months <-> 1 yr, 9 months                                         # => over 1 year
+      #   1 yr, 9 months <-> 2 yr minus 1 sec                                       # => almost 2 years
+      #   2 yrs <-> max time or date                                                # => (same rules as 1 yr)
+      #
+      # With <tt>include_seconds</tt> = true and the difference < 1 minute 29 seconds:
+      #   0-4   secs      # => less than 5 seconds
+      #   5-9   secs      # => less than 10 seconds
+      #   10-19 secs      # => less than 20 seconds
+      #   20-39 secs      # => half a minute
+      #   40-59 secs      # => less than a minute
+      #   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
+      #   distance_of_time_in_words(from_time, from_time + 15.seconds)        # => less than a minute
+      #   distance_of_time_in_words(from_time, from_time + 15.seconds, true)  # => less than 20 seconds
+      #   distance_of_time_in_words(from_time, 3.years.from_now)              # => about 3 years
+      #   distance_of_time_in_words(from_time, from_time + 60.hours)          # => about 3 days
+      #   distance_of_time_in_words(from_time, from_time + 45.seconds, true)  # => less than a minute
+      #   distance_of_time_in_words(from_time, from_time - 45.seconds, true)  # => less than a minute
+      #   distance_of_time_in_words(from_time, 76.seconds.from_now)           # => 1 minute
+      #   distance_of_time_in_words(from_time, from_time + 1.year + 3.days)   # => about 1 year
+      #   distance_of_time_in_words(from_time, from_time + 3.years + 6.months) # => over 3 years
+      #   distance_of_time_in_words(from_time, from_time + 4.years + 9.days + 30.minutes + 5.seconds) # => about 4 years
+      #
+      #   to_time = Time.now + 6.years + 19.days
+      #   distance_of_time_in_words(from_time, to_time, true)     # => about 6 years
+      #   distance_of_time_in_words(to_time, from_time, true)     # => about 6 years
+      #   distance_of_time_in_words(Time.now, Time.now)           # => less than a minute
+      #
+      def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false, options = {})
+        from_time = from_time.to_time if from_time.respond_to?(:to_time)
+        to_time = to_time.to_time if to_time.respond_to?(:to_time)
+        distance_in_minutes = (((to_time - from_time).abs)/60).round
+        distance_in_seconds = ((to_time - from_time).abs).round
 
-        return 'today'     if days >= 0 and days < 1
-        return 'tomorrow'  if days >= 1 and days < 2
-        return 'yesterday' if days >= -1 and days < 0
+        I18n.with_options :locale => options[:locale], :scope => :'datetime.distance_in_words' do |locale|
+          case distance_in_minutes
+            when 0..1
+              return distance_in_minutes == 0 ?
+                     locale.t(:less_than_x_minutes, :count => 1) :
+                     locale.t(:x_minutes, :count => distance_in_minutes) unless include_seconds
 
-        return "in #{days} days"      if days.abs < 60 and days > 0
-        return "#{days.abs} days ago" if days.abs < 60 and days < 0
+              case distance_in_seconds
+                when 0..4   then locale.t :less_than_x_seconds, :count => 5
+                when 5..9   then locale.t :less_than_x_seconds, :count => 10
+                when 10..19 then locale.t :less_than_x_seconds, :count => 20
+                when 20..39 then locale.t :half_a_minute
+                when 40..59 then locale.t :less_than_x_minutes, :count => 1
+                else             locale.t :x_minutes,           :count => 1
+              end
 
-        return date.strftime('%A, %B %e') if days.abs < 182
-        return date.strftime('%A, %B %e, %Y')
+            when 2..44           then locale.t :x_minutes,      :count => distance_in_minutes
+            when 45..89          then locale.t :about_x_hours,  :count => 1
+            when 90..1439        then locale.t :about_x_hours,  :count => (distance_in_minutes.to_f / 60.0).round
+            when 1440..2529      then locale.t :x_days,         :count => 1
+            when 2530..43199     then locale.t :x_days,         :count => (distance_in_minutes.to_f / 1440.0).round
+            when 43200..86399    then locale.t :about_x_months, :count => 1
+            when 86400..525599   then locale.t :x_months,       :count => (distance_in_minutes.to_f / 43200.0).round
+            else
+              distance_in_years           = distance_in_minutes / 525600
+              minute_offset_for_leap_year = (distance_in_years / 4) * 1440
+              remainder                   = ((distance_in_minutes - minute_offset_for_leap_year) % 525600)
+              if remainder < 131400
+                locale.t(:about_x_years,  :count => distance_in_years)
+              elsif remainder < 394200
+                locale.t(:over_x_years,   :count => distance_in_years)
+              else
+                locale.t(:almost_x_years, :count => distance_in_years + 1)
+              end
+          end
+        end
       end
-      alias time_ago time_in_words
 
-      # Returns relative time in words referencing the given date
-      # relative_time_ago(Time.now) => 'about a minute ago'
-      def relative_time_ago(from_time)
-        distance_in_minutes = (((Time.now - from_time.to_time).abs)/60).round
-        case distance_in_minutes
-          when 0..1 then 'about a minute'
-          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..525599 then "#{(distance_in_minutes / 43200).round} months"
-          when 525600..1051199 then 'about 1 year'
-          else "over #{(distance_in_minutes / 525600).round} years"
-        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

data/lib/padrino-helpers/locale/en.yml

@@ -0,0 +1,117 @@
+en:
+  number:
+    # Used in number_with_delimiter()
+    # These are also the defaults for 'currency', 'percentage', 'precision', and 'human'
+    format:
+      # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
+      separator: "."
+      # Delimets thousands (e.g. 1,000,000 is a million) (always in groups of three)
+      delimiter: ","
+      # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
+      precision: 3
+      
+    # Used in number_to_currency()
+    currency:
+      format:
+        # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
+        format: "%u%n"
+        unit: "$"
+        # These three are to override number.format and are optional
+        separator: "."
+        delimiter: ","
+        precision: 2
+        
+    # Used in number_to_percentage()
+    percentage:
+      format:
+        # These three are to override number.format and are optional
+        # separator: 
+        delimiter: ""
+        # precision: 
+        
+    # Used in number_to_precision()
+    precision:
+      format:
+        # These three are to override number.format and are optional
+        # separator:
+        delimiter: ""
+        # precision:
+        
+    # Used in number_to_human_size()
+    human:
+      format:
+        # These three are to override number.format and are optional
+        # separator: 
+        delimiter: ""
+        precision: 1
+      storage_units:
+        # Storage units output formatting.
+        # %u is the storage unit, %n is the number (default: 2 MB)
+        format: "%n %u"
+        units:
+          byte:
+            one:   "Byte"
+            other: "Bytes"
+          kb: "KB"
+          mb: "MB"
+          gb: "GB"
+          tb: "TB"
+
+  # Used in distance_of_time_in_words(), distance_of_time_in_words_to_now(), time_ago_in_words()
+  datetime:
+    distance_in_words:
+      half_a_minute: "half a minute"
+      less_than_x_seconds:
+        one:   "less than 1 second"
+        other: "less than {{count}} seconds"
+      x_seconds:
+        one:   "1 second"
+        other: "{{count}} seconds"
+      less_than_x_minutes:
+        one:   "less than a minute"
+        other: "less than {{count}} minutes"
+      x_minutes:
+        one:   "1 minute"
+        other: "{{count}} minutes"
+      about_x_hours:
+        one:   "about 1 hour"
+        other: "about {{count}} hours"
+      x_days:
+        one:   "1 day"
+        other: "{{count}} days"
+      about_x_months:
+        one:   "about 1 month"
+        other: "about {{count}} months"
+      x_months:
+        one:   "1 month"
+        other: "{{count}} months"
+      about_x_years:
+        one:   "about 1 year"
+        other: "about {{count}} years"
+      over_x_years:
+        one:   "over 1 year"
+        other: "over {{count}} years"
+      almost_x_years:
+        one:   "almost 1 year"
+        other: "almost {{count}} years"
+    prompts:
+      year:   "Year"
+      month:  "Month"
+      day:    "Day"
+      hour:   "Hour"
+      minute: "Minute"
+      second: "Seconds"
+
+  activemodel:
+    errors:
+      template:
+        header:
+          one:    "1 error prohibited this {{model}} from being saved"
+          other:  "{{count}} errors prohibited this {{model}} from being saved"
+        # The variable :count is also available
+        body: "There were problems with the following fields:"
+
+  support:
+    select:
+      # default value for :prompt => true in FormOptionsHelper
+      prompt: "Please select"

data/lib/padrino-helpers/render_helpers.rb

@@ -1,26 +1,6 @@
 module Padrino
   module Helpers
     module RenderHelpers
-      # Renders a erb template based on the relative path
-      # erb_template 'users/new'
-      def erb_template(template_path, options={})
-        render_template template_path, options.merge(:template_engine => :erb)
-      end
-
-      # Renders a haml template based on the relative path
-      # haml_template 'users/new'
-      def haml_template(template_path, options={})
-        render_template template_path, options.merge(:template_engine => :haml)
-      end
-
-      # Renders a template from a file path automatically determining rendering engine
-      # render_template 'users/new'
-      # options = { :template_engine => 'haml' }
-      def render_template(template_path, options={})
-        template_engine = options.delete(:template_engine) || resolve_template_engine(template_path)
-        render template_engine.to_sym, template_path.to_sym, options
-      end
-
       # Partials implementation which includes collections support
       # partial 'photo/_item', :object => @photo
       # partial 'photo/_item', :collection => @photos
@@ -37,27 +17,16 @@ module Padrino
           collection.collect do |member|
             counter += 1
             options[:locals].merge!(object_name => member, "#{object_name}_counter".to_sym => counter)
-            render_template(template_path, options.merge(:layout => false))
+            render(template_path, nil, options.merge(:layout => false))
           end.join("\n")
         else
           if member = options.delete(:object)
             options[:locals].merge!(object_name => member)
           end
-          render_template(template_path, options.merge(:layout => false))
+          render(template_path, nil, options.merge(:layout => false))
         end
       end
-      alias render_partial partial
-
-      private
-
-        # Returns the template engine (i.e haml) to use for a given template_path
-        # resolve_template_engine('users/new') => :haml
-        def resolve_template_engine(template_path)
-          resolved_template_path = File.join(self.options.views, template_path.to_s + ".*")
-          template_file = Dir[resolved_template_path].first
-          raise "Template path '#{template_path}' could not be located in views!" unless template_file
-          template_engine = File.extname(template_file)[1..-1].to_sym
-        end
+      alias :render_partial :partial
     end
   end
 end

data/padrino-helpers.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{padrino-helpers}
-  s.version = "0.2.9"
+  s.version = "0.4.5"
 
   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{2009-12-22}
+  s.date = %q{2010-01-06}
   s.description = %q{Tag helpers, asset helpers, form helpers, form builders and many more helpers for padrino}
   s.email = %q{nesquena@gmail.com}
   s.extra_rdoc_files = [
@@ -28,6 +28,7 @@ Gem::Specification.new do |s|
      "lib/padrino-helpers/form_builder/standard_form_builder.rb",
      "lib/padrino-helpers/form_helpers.rb",
      "lib/padrino-helpers/format_helpers.rb",
+     "lib/padrino-helpers/locale/en.yml",
      "lib/padrino-helpers/output_helpers.rb",
      "lib/padrino-helpers/render_helpers.rb",
      "lib/padrino-helpers/tag_helpers.rb",

data/test/fixtures/render_app/app.rb

@@ -1,41 +1,15 @@
-require 'sinatra/base'
-require 'haml'
+PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
+PADRINO_ENV = 'test' unless defined? PADRINO_ENV
+
+require 'padrino-core'
 
 class RenderUser
   attr_accessor :name
   def initialize(name); @name = name; end
 end
 
-class RenderDemo < Sinatra::Base
-  register Padrino::Helpers
-  
-  configure do
-    set :root, File.dirname(__FILE__)
-  end
-  
-  # haml_template
-  get '/render_haml' do
-    @template = 'haml'
-    haml_template 'haml/test'
-  end
-  
-  # erb_template
-  get '/render_erb' do
-    @template = 'erb'
-    erb_template 'erb/test'
-  end
-  
-  # render_template with explicit engine
-  get '/render_template/:engine' do
-    @template = params[:engine]
-    render_template "template/#{@template}_template", :template_engine => @template
-  end
-  
-  # render_template without explicit engine
-  get '/render_template' do
-    render_template "template/some_template"
-  end
-  
+class RenderDemo < Padrino::Application
+
   # partial with object
   get '/partial/object' do
     partial 'template/user', :object => RenderUser.new('John'), :locals => { :extra => "bar" }

data/test/helper.rb

@@ -5,10 +5,8 @@ require 'mocha'
 require 'rack/test'
 require 'webrat'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'support_helpers'
-require File.dirname(__FILE__) + '/../lib/padrino-helpers'
+require 'padrino-helpers'
 
 class Test::Unit::TestCase
   include Padrino::Helpers::OutputHelpers

data/test/support_helpers.rb

@@ -1,5 +1,20 @@
+require 'padrino-core/support_lite'
 unless Fixnum.method_defined?(:days)
-  require 'active_support/core_ext/object/misc'
+  # 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
+      # to define an acts_like_date? method, and extends Time to define
+      # acts_like_time?. As a result, we can do "x.acts_like?(:time)" and
+      # "x.acts_like?(:date)" to do duck-type-safe comparisons, since classes that
+      # we want to act like Time simply need to define an acts_like_time? method.
+      def acts_like?(duck)
+        respond_to? "acts_like_#{duck}?"
+      end
+    end
+  else
+    require 'active_support/core_ext/object/misc'
+  end
   require 'active_support/core_ext/date'
   require 'active_support/core_ext/time'
   require 'active_support/core_ext/numeric'

data/test/test_format_helpers.rb

@@ -87,60 +87,57 @@ class TestFormatHelpers < Test::Unit::TestCase
     end
   end
 
-  context 'for #time_in_words method' do
+  context 'for #time_ago_in_words method' do
     should "display today" do
-      assert_equal 'today', time_in_words(Time.now)
+      assert_equal 'less than a minute', time_ago_in_words(Time.now)
     end
     should "display yesterday" do
-      assert_equal 'yesterday', time_in_words(1.day.ago)
+      assert_equal '1 day', time_ago_in_words(1.day.ago)
     end
     should "display tomorrow" do
-      assert_equal 'tomorrow', time_in_words(1.day.from_now)
+      assert_equal '1 day', time_ago_in_words(1.day.from_now)
     end
     should "return future number of days" do
-      assert_equal 'in 4 days', time_in_words(4.days.from_now)
+      assert_equal '4 days', time_ago_in_words(4.days.from_now)
     end
     should "return past days ago" do
-      assert_equal '4 days ago', time_in_words(4.days.ago)
+      assert_equal '4 days', time_ago_in_words(4.days.ago)
     end
     should "return formatted archived date" do
-      assert_equal 100.days.ago.strftime('%A, %B %e'), time_in_words(100.days.ago)
+      assert_equal '3 months', time_ago_in_words(100.days.ago)
     end
     should "return formatted archived year date" do
-      assert_equal 500.days.ago.strftime('%A, %B %e, %Y'), time_in_words(500.days.ago)
+      assert_equal 'over 1 year', time_ago_in_words(500.days.ago)
     end
-  end
-
-  context 'for #relative_time_ago method' do
     should 'display now as a minute ago' do
-      assert_equal 'about a minute', relative_time_ago(1.minute.ago)
+      assert_equal '1 minute', time_ago_in_words(1.minute.ago)
     end
     should "display a few minutes ago" do
-      assert_equal '4 minutes', relative_time_ago(4.minute.ago)
+      assert_equal '4 minutes', time_ago_in_words(4.minute.ago)
     end
     should "display an hour ago" do
-      assert_equal 'about 1 hour', relative_time_ago(1.hour.ago + 5.minutes.ago.sec)
+      assert_equal 'about 1 hour', time_ago_in_words(1.hour.ago + 5.minutes.ago.sec)
     end
     should "display a few hours ago" do
-      assert_equal 'about 3 hours', relative_time_ago(3.hour.ago + 5.minutes.ago.sec)
+      assert_equal 'about 3 hours', time_ago_in_words(3.hour.ago + 5.minutes.ago.sec)
     end
     should "display a day ago" do
-      assert_equal '1 day', relative_time_ago(1.day.ago)
+      assert_equal '1 day', time_ago_in_words(1.day.ago)
     end
     should "display a few days ago" do
-      assert_equal '5 days', relative_time_ago(5.days.ago - 5.minutes.ago.sec)
+      assert_equal '5 days', time_ago_in_words(5.days.ago - 5.minutes.ago.sec)
     end
     should "display a month ago" do
-      assert_equal 'about 1 month', relative_time_ago(32.days.ago + 5.minutes.ago.sec)
+      assert_equal 'about 1 month', time_ago_in_words(32.days.ago + 5.minutes.ago.sec)
     end
     should "display a few months ago" do
-      assert_equal '6 months', relative_time_ago(180.days.ago - 5.minutes.ago.sec)
+      assert_equal '6 months', time_ago_in_words(180.days.ago - 5.minutes.ago.sec)
     end
     should "display a year ago" do
-      assert_equal 'about 1 year', relative_time_ago(365.days.ago - 5.minutes.ago.sec)
+      assert_equal 'about 1 year', time_ago_in_words(365.days.ago - 5.minutes.ago.sec)
     end
     should "display a few years ago" do
-      assert_equal 'over 7 years', relative_time_ago(2800.days.ago - 5.minutes.ago.sec)
+      assert_equal 'over 7 years', time_ago_in_words(2800.days.ago - 5.minutes.ago.sec)
     end
   end
 

data/test/test_render_helpers.rb

@@ -6,34 +6,6 @@ class TestRenderHelpers < Test::Unit::TestCase
     RenderDemo.tap { |app| app.set :environment, :test }
   end
 
-  context 'for #haml_template method' do
-    setup { visit '/render_haml' }
-    should('render template properly') do
-      assert_have_selector "h1", :content => "This is a haml template!"
-    end
-  end
-
-  context 'for #erb_template method' do
-    setup { visit '/render_erb' }
-    should('render template properly') do
-      assert_have_selector "h1", :content => "This is a erb template!"
-    end
-  end
-  
-  context 'for #render_template method with explicit engine' do
-    setup { visit '/render_template/haml' }
-    should('render template properly') do
-      assert_have_selector "h1", :content => "This is a haml template sent from render_template!"
-    end
-  end
-  
-  context 'for #render_template method without explicit engine' do
-    setup { visit '/render_template' }
-    should('render template properly') do
-      assert_have_selector "h1", :content => "This is a haml template which was detected!"
-    end
-  end
-  
   context 'for #partial method and object' do
     setup { visit '/partial/object' }
     should "render partial html with object" do
@@ -46,7 +18,7 @@ class TestRenderHelpers < Test::Unit::TestCase
       assert_have_selector 'p', :content => "Extra is bar"
     end
   end
-  
+
   context 'for #partial method and collection' do
     setup { visit '/partial/collection' }
     should "render partial html with collection" do
@@ -61,7 +33,7 @@ class TestRenderHelpers < Test::Unit::TestCase
       assert_have_selector 'p', :content => "Extra is bar"
     end
   end
-  
+
   context 'for #partial method and locals' do
     setup { visit '/partial/locals' }
     should "render partial html with locals" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-helpers
 version: !ruby/object:Gem::Version 
-  version: 0.2.9
+  version: 0.4.5
 platform: ruby
 authors: 
 - Padrino Team
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-22 00:00:00 -08:00
+date: 2010-01-06 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -106,6 +106,7 @@ files:
 - lib/padrino-helpers/form_builder/standard_form_builder.rb
 - lib/padrino-helpers/form_helpers.rb
 - lib/padrino-helpers/format_helpers.rb
+- lib/padrino-helpers/locale/en.yml
 - lib/padrino-helpers/output_helpers.rb
 - lib/padrino-helpers/render_helpers.rb
 - lib/padrino-helpers/tag_helpers.rb