BrianTheCoder-ratpack 0.2.4 → 0.3.1

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 2
-:patch: 4
 :major: 0
+:minor: 3
+:patch: 2

data/lib/ratpack.rb

@@ -22,7 +22,7 @@ module RatPack
     dir ||= ::File.basename(fname, '.*')
     search_me = ::File.expand_path(
         ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
-    Dir.glob(search_me).sort.each {|rb| require rb}
+    Dir.glob(search_me).sort.each {|rb| require rb }
   end
 end  # module RatPack
 

data/lib/ratpack/date_time_formatting.rb

@@ -0,0 +1,155 @@
+module DateAndTimeFormatting  
+  def self.included(base)
+    base.class_eval do
+      include DateAndTimeFormatting::InstanceMethods
+      include OrdinalizedFormatting
+      extend DateAndTimeFormatting::ClassMethods
+    end
+  end
+  
+  module InstanceMethods
+    
+    
+    # Formats a date/time instance using a defined format
+    #
+    # ==== Parameters
+    # format<Symbol>:: of the format key from Date.date_formats
+    #
+    # ==== Returns
+    # String:: formatted string
+    # 
+    # ==== Example
+    #   Time.now.formatted(:rfc822) # => "Sun, 16 Nov 2007 00:21:16 -0800"
+    #   Time.now.formatted(:db) # => "2008-11-16 00:22:09"
+    #
+    # You can also add your own formats using +Date.add_format+ when your app loads.
+    #
+    # # Add the following to your init.rb
+    #   Merb::BootLoader.before_app_loads do
+    #     Date.add_format(:matt, "%H:%M:%S %Y-%m-%d")
+    #   end
+    #
+    # # Format a Time instance with the format you just specified
+    #   Time.now.formatted(:matt) # => "00:00:00 2007-11-02"
+    #
+    #--
+    # @public
+    def formatted(format = :default)
+      self.strftime(Date.formats[format])
+    end
+  
+  end
+  
+  module ClassMethods
+    
+    @@formats = {
+      :db             => "%Y-%m-%d %H:%M:%S", 
+      :time           => "%H:%M", # 21:12
+      :date           => "%Y-%m-%d", # 2008-12-04
+      :short          => "%d %b %H:%M", # 01 Sep 21:12
+      :long           => "%B %d, %Y %H:%M",
+      :rfc822         => "%a, %d %b %Y %H:%M:%S %z"
+    }
+    
+    # Lists the date and time formats
+    #
+    # ==== Returns
+    # Hash:: a hash with all formats available
+    # --
+    # @public
+    def formats
+      @@formats
+    end
+    
+    # Adds a date and time format
+    # 
+    # Because this operation is not thread safe, you should define
+    # custom formats when you load you application. The recommended way
+    # to do that, is to use the before_app_loads bootloader.
+    #
+    # If you want to add a format at runtime, you will need to use a mutex
+    # and synchronize it yourself.
+    #
+    # ==== Parameters
+    # key<Symbol>:: name of the format
+    # format<Hash>:: time format to use
+    #
+    # ==== Returns
+    # Hash:: a hash with all formats available
+    #
+    # ==== Example
+    #
+    #   Merb::BootLoader.before_app_loads do
+    #     Date.add_format(:matt, "%H:%M:%S %Y-%m-%d")
+    #   end
+    # 
+    #
+    # --
+    # @public
+    def add_format(key, format)
+      formats.merge!({key => format})
+    end
+    
+    
+    # Resets the date and time formats
+    # --
+    # @private
+    def reset_formats
+      original_formats = [:db, :time, :short, :date, :long, :long_ordinal, :rfc822]
+      formats = @@formats.delete_if{|format, v| !original_formats.include?(format)}
+    end
+
+  end
+  
+end
+
+module Ordinalize
+  # Ordinalize turns a number into an ordinal string used to denote the
+  # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  # ==== Examples
+  #   1.ordinalize     # => "1st"
+  #   2.ordinalize     # => "2nd"
+  #   1002.ordinalize  # => "1002nd"
+  #   1003.ordinalize  # => "1003rd"
+  def ordinalize
+    if (11..13).include?(self % 100)
+      "#{self}th"
+    else
+      case self % 10
+        when 1; "#{self}st"
+        when 2; "#{self}nd"
+        when 3; "#{self}rd"
+        else    "#{self}th"
+      end
+    end
+  end
+end
+
+Integer.send :include, Ordinalize
+
+# Time.now.to_ordinalized_s :long
+# => "February 28th, 2006 21:10"
+module OrdinalizedFormatting
+  
+  def to_ordinalized_s(format = :default)
+    format = Date.formats[format] 
+    return self.to_s if format.nil?
+    strftime_ordinalized(format)
+  end
+
+  # Gives you a relative date in an attractive format
+  #
+  # ==== Parameters
+  # format<String>:: strftime string used to format a time/date object
+  # locale<String, Symbol>:: An optional value which can be used by localization plugins
+  #
+  # ==== Returns
+  # String:: Ordinalized time/date object
+  #
+  # ==== Examples
+  #    5.days.ago.strftime_ordinalized('%b %d, %Y')     # => 
+  def strftime_ordinalized(fmt, format=nil)
+    strftime(fmt.gsub(/(^|[^-])%d/, '\1_%d_')).gsub(/_(\d+)_/) { |s| s.to_i.ordinalize }
+  end
+end

data/lib/ratpack/date_time_helpers.rb

@@ -0,0 +1,183 @@
+# Provides a number of methods for displaying and dealing with dates and times
+#
+# Parts were strongly based on http://ar-code.svn.engineyard.com/plugins/relative_time_helpers/, and
+# active_support
+#
+# The key methods are `relative_date`, `relative_date_span`, and `relative_time_span`.  This also gives
+# you the Rails style Time DSL for working with numbers eg. 3.months.ago or 5.days.until(1.year.from_now)
+module RatPack
+  module DateAndTime
+    @@time_class = Time
+    @@time_output = {
+      :today          => 'today',
+      :yesterday      => 'yesterday',
+      :tomorrow       => 'tomorrow',
+      :initial_format => '%b %d',
+      :year_format    => ', %Y'
+    }
+  
+    def self.time_class
+      @@time_class
+    end
+  
+    # ==== Parameters
+    # format<Symbol>:: time format to use
+    # locale<String, Symbol>:: An optional value which can be used by localization plugins
+    #
+    # ==== Returns
+    # String:: a string used to format time using #strftime
+    def self.time_output(format, locale=nil)
+      @@time_output[format]
+    end
+  
+    # Gives you a relative date in an attractive format
+    #
+    # ==== Parameters
+    # time<~to_date>:: The Date or Time to test
+    # locale<String, Symbol>:: An optional value which can be used by localization plugins
+    #
+    # ==== Returns
+    # String:: Relative date
+    #
+    # ==== Examples
+    #   relative_date(Time.now.utc) => "today"
+    #   relative_date(5.days.ago) => "March 5th"
+    #   relative_date(1.year.ago) => "March 10th, 2007"
+    def relative_date(time, locale=nil)
+      date  = time.to_date
+      today = DateAndTime.time_class.now.to_date
+      if date == today
+        DateAndTime.time_output(:today, locale)
+      elsif date == (today - 1)
+        DateAndTime.time_output(:yesterday, locale)
+      elsif date == (today + 1)
+        DateAndTime.time_output(:tomorrow, locale)
+      else
+        fmt  = DateAndTime.time_output(:initial_format, locale).dup
+        fmt << DateAndTime.time_output(:year_format, locale) unless date.year == today.year
+        time.strftime_ordinalized(fmt, locale)
+      end
+    end
+  
+    # Gives you a relative date span in an attractive format
+    #
+    # ==== Parameters
+    # times<~first,~last>:: The Dates or Times to test
+    #
+    # ==== Returns
+    # String:: The sexy relative date span
+    #
+    # ==== Examples
+    #   relative_date([1.second.ago, 10.seconds.ago]) => "March 10th"
+    #   relative_date([1.year.ago, 1.year.ago) => "March 10th, 2007"
+    #   relative_date([Time.now, 1.day.from_now]) => "March 10th - 11th"
+    #   relative_date([Time.now, 1.year.ago]) => "March 10th, 2007 - March 10th, 2008"
+    def relative_date_span(times)
+      times = [times.first, times.last].collect! { |t| t.to_date }
+      times.sort!
+      if times.first == times.last
+        relative_date(times.first)
+      else
+        first = times.first; last = times.last; now = DateAndTime.time_class.now
+        arr = [first.strftime_ordinalized('%b %d')]
+        arr << ", #{first.year}" unless first.year == last.year
+        arr << ' - '
+        arr << last.strftime('%b') << ' ' unless first.year == last.year && first.month == last.month
+        arr << last.day.ordinalize
+        arr << ", #{last.year}" unless first.year == last.year && last.year == now.year
+        arr.to_s
+      end
+    end
+  
+    # Gives you a relative date span in an attractive format
+    #
+    # ==== Parameters
+    # times<~first,~last>:: The Dates or Times to test
+    #
+    # ==== Returns
+    # String:: The sexy relative time span
+    #
+    # ==== Examples
+    #   relative_time_span([1.second.ago, 10.seconds.ago]) => "12:00 - 12:09 AM March 10th"
+    #   relative_time_span([1.year.ago, 1.year.ago) => "12:09 AM March 10th, 2007"
+    #   relative_time_span([Time.now, 13.hours.from_now]) => "12:09 AM - 1:09 PM March 10th"
+    #   relative_time_span([Time.now, 1.year.ago]) => "12:09 AM March 10th, 2007 - 12:09 AM March 10th, 2008"
+    def relative_time_span(times)
+      times = [times.first, times.last].collect! { |t| t.to_time }
+      times.sort!
+      if times.first == times.last
+        "#{prettier_time(times.first)} #{relative_date(times.first)}"
+      elsif times.first.to_date == times.last.to_date
+          same_half = (times.first.hour/12 == times.last.hour/12)
+          "#{prettier_time(times.first, !same_half)} - #{prettier_time(times.last)} #{relative_date(times.first)}"
+  
+      else
+        first = times.first; last = times.last; now = DateAndTime.time_class.now        
+        arr = [prettier_time(first)]
+        arr << ' '
+        arr << first.strftime_ordinalized('%b %d')
+        arr << ", #{first.year}" unless first.year == last.year
+        arr << ' - '
+        arr << prettier_time(last)
+        arr << ' '
+        arr << last.strftime('%b') << ' ' unless first.year == last.year && first.month == last.month
+        arr << last.day.ordinalize
+        arr << ", #{last.year}" unless first.year == last.year && last.year == now.year
+        arr.to_s
+      end
+    end
+  
+    # Condenses time... very similar to time_ago_in_words in ActionPack
+    #
+    # ==== Parameters
+    # from_time<~to_time>:: The Date or Time to start from
+    # to_time<~to_time>:: The Date or Time to go to, Defaults to Time.now.utc
+    # include_seconds<Boolean>:: Count the seconds initially, Defaults to false
+    # locale<String, Symbol>:: An optional value which can be used by localization plugins
+    #
+    # ==== Returns
+    # String:: The time distance
+    #
+    # ==== Examples
+    # time_lost_in_words(3.minutes.from_now)           # => 3 minutes
+    # time_lost_in_words(Time.now - 15.hours)          # => 15 hours
+    # time_lost_in_words(Time.now, 3.minutes.from_now) # => 3 minutes
+    # time_lost_in_words(Time.now)                     # => less than a minute
+    # time_lost_in_words(Time.now, Time.now, true)     # => less than 5 seconds
+    #
+    def time_lost_in_words(from_time, to_time = Time.now.utc, include_seconds = false, locale=nil)
+      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
+  
+      case distance_in_minutes
+        when 0..1
+          return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
+          case distance_in_seconds
+            when 0..4   then 'less than 5 seconds'
+            when 5..9   then 'less than 10 seconds'
+            when 10..19 then 'less than 20 seconds'
+            when 20..39 then 'half a minute'
+            when 40..59 then 'less than a minute'
+            else             '1 minute'
+          end
+  
+        when 2..44           then "#{distance_in_minutes} minutes"
+        when 45..89          then 'about 1 hour'
+        when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
+        when 1440..2879      then '1 day'
+        when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
+        when 43200..86399    then 'about 1 month'
+        when 86400..525599   then "#{(distance_in_minutes / 43200).round} months"
+        when 525600..1051199 then 'about 1 year'
+        else                      "over #{(distance_in_minutes / 525600).round} years"
+      end
+    end
+    alias :time_ago_in_words :time_lost_in_words
+  
+    def prettier_time(time, ampm=true, locale=nil)
+      time.strftime("%I:%M#{" %p" if ampm}").sub(/^0/, '')
+    end
+  end
+end

data/lib/ratpack/forms.rb

@@ -3,7 +3,7 @@ module RatPack
     def error_messages_for(obj = nil, opts = {})
       return unless obj.respond_to?(:errors)
       return if obj.errors.blank?
-      html = tag(:h2, "Form submission failed be cause of #{obj.errors.size} #{pluralize("error",obj.errors.size)}")
+      html = tag(:h2, "Form submission failed because of #{obj.errors.size} #{pluralize("error",obj.errors.size)}")
       msgs = obj.errors.map{|error| error.map{|msg| tag(:li,msg)}}.flatten
       tag(:div, html + tag(:ul,msgs), :class => "error")
     end
@@ -40,6 +40,7 @@ module RatPack
     def check_box(attrs)
       html = ""
       label = build_field(attrs)
+      attrs[:checked] = "checked" if attrs[:checked]
       if attrs.delete(:boolean)
         on, off = attrs.delete(:on), attrs.delete(:off)
         html << hidden_field(:name => attrs[:name], :value => off)
@@ -73,15 +74,19 @@ module RatPack
     private
     
     def form_field(type, content, attrs)
-      attrs[:id] = attrs[:name].gsub(/(\[)(.+?)\]$/,'_\2') unless attrs.has_key?(:id)
+      attrs[:id] = sanitize_name(attrs[:name]) unless attrs.has_key?(:id)
       build_field(attrs) + tag(type, content, attrs)
     end
     
     def closed_form_field(type, attrs)
-      attrs[:id] = attrs[:name].gsub(/(\[)(.+?)\]$/,'_\2') unless attrs.has_key?(:id)
+      attrs[:id] = sanitize_name(attrs[:name]) unless attrs.has_key?(:id)
       build_field(attrs) + self_closing_tag(type, attrs)
     end
     
+    def sanitize_name(name)
+      name.gsub(/\[\]$/,'').gsub(/(\[)(.+?)\]$/,'_\2')
+    end
+    
     def build_field(attrs)
       label = attrs.has_key?(:label) ? build_label(attrs) : ""
       hint = attrs.has_key?(:hint) ? tag(:div,attrs.delete(:hint), :class => "hint") : ""

data/lib/ratpack/html_helpers.rb

@@ -10,7 +10,8 @@ module RatPack
     end
     
     def image_tag(file,attrs = {})
-      defaults = {:src => "/images/#{file}"}
+      file = "/images/#{file}" unless remote_asset?(file)
+      defaults = {:src => file }  
       self_closing_tag(:img,defaults.merge(options))
     end
 
@@ -28,19 +29,15 @@ module RatPack
     end
     
     def partial(template, opts = {})
-      template_engine = opts.delete(:template) || :erb
+      engine = opts.delete(:template) || :erb
       opts.merge!(:layout => false)
-      template = :"partials/#{template}"
+      path = :"partials/#{template}"
       if collection = opts.delete(:collection) then
-        collection.inject([]) do |buffer, member|
-          buffer << send(template_engine,template, opts.merge(
-                                    :layout => false, 
-                                    :locals => {template.to_sym => member}
-                                  )
-                       )
+        collection.map do |member|
+          send(engine,path, opts.merge(:locals => {template.to_sym => member}))
         end.join("\n")
       else
-        send(template_engine,template, opts)
+        send(engine,path, opts)
       end
     end
     

data/lib/ratpack/time_dsl.rb

@@ -0,0 +1,59 @@
+# Provides a a simple way of calling time units and to see the elapsed time between 2 moments
+# ==== Examples
+#   142.minutes => returns a value in seconds
+#   7.days => returns a value in seconds
+#   1.week => returns a value in seconds
+#   2.weeks.ago => returns a date
+#   1.year.since(time) => returns a date
+#   5.months.since(2.weeks.from_now) => returns a date
+module TimeDSL
+  
+  def second
+    self * 1
+  end
+  alias_method :seconds, :second
+  
+  def minute
+    self * 60
+  end
+  alias_method :minutes, :minute
+  
+  def hour
+    self * 3600
+  end
+  alias_method :hours, :hour
+  
+  def day
+    self * 86400
+  end
+  alias_method :days, :day
+  
+  def week
+    self * 604800
+  end
+  alias_method :weeks, :week
+  
+  def month
+    self * 2592000
+  end
+  alias_method :months, :month
+  
+  def year
+    self * 31471200
+  end
+  alias_method :years, :year
+  
+  # Reads best without arguments:  10.minutes.ago
+  def ago(time = ::Time.now)
+    time - self
+  end
+  alias :until :ago
+  
+  # Reads best with argument:  10.minutes.since(time)
+  def since(time = ::Time.now)
+    time + self
+  end
+  alias :from_now :since
+end
+
+Numeric.send :include, TimeDSL

data/lib/sinatra/ratpack.rb

@@ -5,6 +5,7 @@ module Sinatra
       app.helpers ::RatPack::HtmlHelpers
       app.helpers ::RatPack::Routes
       app.helpers ::RatPack::Forms
+      app.helpers ::RatPack::DateAndTime
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: BrianTheCoder-ratpack
 version: !ruby/object:Gem::Version 
-  version: 0.2.4
+  version: 0.3.1
 platform: ruby
 authors: 
 - brianthecoder
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-14 00:00:00 -07:00
+date: 2009-04-25 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -29,10 +29,13 @@ files:
 - VERSION.yml
 - lib/ratpack.rb
 - lib/ratpack/core_ext/hash.rb
+- lib/ratpack/date_time_formatting.rb
+- lib/ratpack/date_time_helpers.rb
 - lib/ratpack/forms.rb
 - lib/ratpack/html_helpers.rb
 - lib/ratpack/routes.rb
 - lib/ratpack/tag.rb
+- lib/ratpack/time_dsl.rb
 - lib/sinatra/ratpack.rb
 - test/ratpack_test.rb
 - test/test_helper.rb
@@ -60,7 +63,7 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A collection of helpers I wanted for sinatra, thought I'd share
 test_files: 
 - test/ratpack_test.rb