module ActionView::Helpers::DateHelper

all month choices are valid.
Note: If the day is not included as an option but the month is, the day will be set to the 1st to ensure that

The selects are prepared for multi-parameter assignment to an Active Record object.

date_select("article", "written_on", day_format: ->(day) { day.ordinalize })
# Generates a date select with custom day format.

date_select("article", "written_on", year_format: ->(year) { "Heisei #{year - 1988}" })
# Generates a date select with custom year format.

date_select("article", "written_on", prompt: { day: 'Select day', month: 'Select month', year: 'Select year' })
# Generates a date select with custom prompts.

date_select("credit_card", "bill_due", default: { day: 20 })
# that will have a default day of 20.
# Generates a date select that when POSTed is stored in the credit_card variable, in the bill_due attribute

date_select("article", "written_on", selected: Date.today)
# which is set in the form with today's date, regardless of the value in the Active Record object.
# Generates a date select that when POSTed is stored in the article variable, in the written_on attribute

date_select("article", "written_on", default: 3.days.from_now)
# which is initially set to the date 3 days from the current date
# Generates a date select that when POSTed is stored in the article variable, in the written_on attribute

date_select("user", "birthday", order: [:month, :day])
# lacking a year field.
# Generates a date select that when POSTed is stored in the user variable, in the birthday attribute

date_select("article", "written_on", order: [:day, :month, :year])
# with the fields ordered as day, month, year rather than month, day, year.
# Generates a date select that when POSTed is stored in the article variable, in the written_on attribute

date_select("article", "written_on", use_two_digit_numbers: true)
# with two digit numbers used for months and days.
# Generates a date select that when POSTed is stored in the article variable, in the written_on attribute,

discard_day: true, include_blank: true)
date_select("article", "written_on", start_year: 1995, use_month_numbers: true,
# and without a day select box.
# with the year in the year drop down box starting at 1995, numbers used for months instead of words,
# Generates a date select that when POSTed is stored in the article variable, in the written_on attribute,

date_select("article", "written_on", start_year: 1995)
# with the year in the year drop down box starting at 1995.
# Generates a date select that when POSTed is stored in the article variable, in the written_on attribute,

date_select("article", "written_on")
# Generates a date select that when POSTed is stored in the article variable, in the written_on attribute.

NOTE: Discarded selects will default to 1. So if no month select is available, January will be assumed.

If anything is passed in the +html_options+ hash it will be applied to every select tag in the set.

* :use_hidden - Set to true if you only want to generate hidden input tags.
will extend the select type with the given value. Use +html_options+ to modify every select tag in the set.
strings for :year, :month, :day, :hour, :minute, :second
select tags. This automatically set classes 'year', 'month', 'day', 'hour', 'minute' and 'second'. A hash of
* :with_css_classes - Set to true or a hash of strings. Use true if you want to assign generic styles for
or the given prompt string.
Setting this option prepends a select option with a generic prompt (Day, Month, Year, Hour, Minute, Seconds)
for :year, :month, :day, :hour, :minute and :second.
* :prompt - Set to true (for a generic prompt), a prompt string or a hash of prompt strings
* :disabled - Set to true if you want show the select fields as disabled.
* :selected - Set a date that overrides the actual value.
* :default - Set a default date if the affected date isn't set or is +nil+.
dates.
* :include_blank - Include a blank option in every select field so it's possible to set empty
the respective locale (e.g. [:year, :month, :day] in the en locale that ships with Rails).
select will not be shown (like when you set discard_xxx: true. Defaults to the order defined in
customize the order in which the select fields are shown. If you leave out any of the symbols, the respective
* :order - Set to an array containing :day, :month and :year to
as a hidden field instead of showing a select field.
* :discard_year - Set to true if you don't want to show a year select. This includes the year
as a hidden field instead of showing a select field. Also note that this implicitly sets :discard_day to true.
* :discard_month - Set to true if you don't want to show a month select. This includes the month
first of the given month in order to not create invalid dates like 31 February.
as a hidden field instead of showing a select field. Also note that this implicitly sets the day to be the
* :discard_day - Set to true if you don't want to show a day select. This includes the day
* :day_format - Set format of days for day select. Lambda should be passed.
* :year_format - Set format of years for year select. Lambda should be passed.
the current selected year plus 5.
you are creating new record. While editing existing record, :end_year defaults to
* :end_year - Set the end year for the year select. Default is Date.today.year + 5 if
the current selected year minus 5.
you are creating new record. While editing existing record, :start_year defaults to
* :start_year - Set the start year for the year select. Default is Date.today.year - 5 if
* :datetime_separator- Specifies a string to separate the date and time fields. Default is " — ".
* :time_separator - Specifies a string to separate the time fields. Default is " : ".
* :date_separator - Specifies a string to separate the date fields. Default is "" (i.e. nothing).
See Kernel.sprintf for documentation on format sequences.
and +:name+ (string). A format string would be something like "%{name} (%02d)" for example.
* :month_format_string - Set to a format string. The string gets passed keys +:number+ (integer)
Note: You can also use Rails' i18n functionality for this.
* :use_month_names - Set to an array with 12 month names if you want to customize month names.
"2 - February" instead of "February").
* :add_month_numbers - Set to true if you want to use both month numbers and month names (e.g.
month names (e.g. "Feb" instead of "February").
* :use_short_month - Set to true if you want to use abbreviated month names instead of full
"02" instead of "February" and "08" instead of "8").
* :use_two_digit_numbers - Set to true if you want to display two digit month and day numbers (e.g.
"2" instead of "February").
* :use_month_numbers - Set to true if you want to use month numbers rather than month names (e.g.
==== Options

attribute (identified by +method+) on an object assigned to the template (identified by +object+).
Returns a set of select tags (one for year, month, and day) pre-selected for accessing a specified date-based

def date_select(object_name, method, options = {}, html_options = {})
  Tags::DateSelect.new(object_name, method, self, options, html_options).render
end

The selects are prepared for multi-parameter assignment to an Active Record object.

datetime_select("article", "written_on", prompt: true) # generic prompts for all
datetime_select("article", "written_on", prompt: { hour: true }) # generic prompt for hours
datetime_select("article", "written_on", prompt: { day: 'Choose day', month: 'Choose month', year: 'Choose year' })
# Generates a datetime select with a custom prompt. Use prompt: true for generic prompts.

datetime_select("article", "written_on", discard_type: true)
# as the written_on attribute.
# Generates a datetime select that discards the type that, when POSTed, will be stored in the article variable

datetime_select("article", "written_on", ampm: true)
# Generate a datetime select with hours in the AM/PM format

datetime_select("trip", "departing", default: 3.days.from_now)
# be stored in the trip variable in the departing attribute.
# Generates a datetime select with a default value of 3 days from the current time that, when POSTed, will

datetime_select("article", "written_on", start_year: 1995)
# article variable in the written_on attribute.
# Generates a datetime select with a year select that starts at 1995 that, when POSTed, will be stored in the

datetime_select("article", "written_on")
# attribute.
# Generates a datetime select that, when POSTed, will be stored in the article variable in the written_on

If anything is passed in the html_options hash it will be applied to every select tag in the set.

by +object+).
specified datetime-based attribute (identified by +method+) on an object assigned to the template (identified
Returns a set of select tags (one for year, month, day, hour, and minute) pre-selected for accessing a

def datetime_select(object_name, method, options = {}, html_options = {})
  Tags::DatetimeSelect.new(object_name, method, self, options, html_options).render
end

distance_of_time_in_words(from_time, from_time + 3.hours, scope: 'datetime.distance_in_words.short') # => "3 hours"
distance_of_time_in_words(from_time, from_time + 50.minutes, scope: 'datetime.distance_in_words.short') # => "an hour"
from_time = Time.now

Which will then result in the following:

for more examples.
See https://github.com/svenfuchs/rails-i18n/blob/master/rails/locale/en.yml

other: '%{count} hours'
one: 'an hour'
about_x_hours:
short:
distance_in_words:
datetime:

For example you can define the following in your locale (e.g. en.yml).

to look up the translation.
With the scope option, you can define a custom scope for Rails

distance_of_time_in_words(Time.now, Time.now) # => less than a minute
distance_of_time_in_words(to_time, from_time, include_seconds: true) # => about 6 years
distance_of_time_in_words(from_time, to_time, include_seconds: true) # => about 6 years
to_time = Time.now + 6.years + 19.days

distance_of_time_in_words(from_time, from_time + 4.years + 9.days + 30.minutes + 5.seconds) # => about 4 years
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 + 1.year + 3.days) # => about 1 year
distance_of_time_in_words(from_time, 76.seconds.from_now) # => 1 minute
distance_of_time_in_words(from_time, from_time - 45.seconds, include_seconds: true) # => less than a minute
distance_of_time_in_words(from_time, from_time + 45.seconds, include_seconds: true) # => less than a minute
distance_of_time_in_words(from_time, from_time + 60.hours) # => 3 days
distance_of_time_in_words(from_time, 3.years.from_now) # => about 3 years
distance_of_time_in_words(from_time, from_time + 15.seconds, include_seconds: true) # => less than 20 seconds
distance_of_time_in_words(from_time, from_time + 15.seconds) # => less than a minute
distance_of_time_in_words(from_time, 50.minutes.from_now) # => about 1 hour
distance_of_time_in_words(from_time, from_time + 50.minutes) # => about 1 hour
from_time = Time.now

60-89 secs # => 1 minute
40-59 secs # => less than a minute
20-39 secs # => half a minute
10-19 secs # => less than 20 seconds
5-9 secs # => less than 10 seconds
0-4 secs # => less than 5 seconds
With include_seconds: true and the difference < 1 minute 29 seconds:

2 yrs <-> max time or date # => (same rules as 1 yr)
1 yr, 9 months <-> 2 yr minus 1 sec # => almost 2 years
1 yr, 3 months <-> 1 yr, 9 months # => over 1 year
1 yr <-> 1 yr, 3 months # => about 1 year
59 days, 23 hrs, 59 mins, 30 secs <-> 1 yr minus 1 sec # => [2..12] months
44 days, 23 hrs, 59 mins, 30 secs <-> 59 days, 23 hrs, 59 mins, 29 secs # => about 2 months
29 days, 23 hrs, 59 mins, 30 secs <-> 44 days, 23 hrs, 59 mins, 29 secs # => about 1 month
41 hrs, 59 mins, 30 secs <-> 29 days, 23 hrs, 59 mins, 29 secs # => [2..29] days
23 hrs, 59 mins, 30 secs <-> 41 hrs, 59 mins, 29 secs # => 1 day
89 mins, 30 secs <-> 23 hrs, 59 mins, 29 secs # => about [2..24] hours
44 mins, 30 secs <-> 89 mins, 29 secs # => about 1 hour
1 min, 30 secs <-> 44 mins, 29 secs # => [2..44] minutes
30 secs <-> 1 min, 29 secs # => 1 minute
0 <-> 29 secs # => less than a minute

Distances are reported based on the following table:
Pass include_seconds: true if you want more detailed approximations when distance < 1 min, 29 secs.
Reports the approximate distance in time between two Time, Date, or DateTime objects or integers as seconds.

def distance_of_time_in_words(from_time, to_time = 0, options = {})
  options = {
    scope: :'datetime.distance_in_words'
  }.merge!(options)
  from_time = normalize_distance_of_time_argument_to_time(from_time)
  to_time = normalize_distance_of_time_argument_to_time(to_time)
  from_time, to_time = to_time, from_time if from_time > to_time
  distance_in_minutes = ((to_time - from_time) / 60.0).round
  distance_in_seconds = (to_time - from_time).round
  I18n.with_options locale: options[:locale], scope: options[:scope] 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 options[:include_seconds]
      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
    when 2...45           then locale.t :x_minutes,      count: distance_in_minutes
    when 45...90          then locale.t :about_x_hours,  count: 1
      # 90 mins up to 24 hours
    when 90...1440        then locale.t :about_x_hours,  count: (distance_in_minutes.to_f / 60.0).round
      # 24 hours up to 42 hours
    when 1440...2520      then locale.t :x_days,         count: 1
      # 42 hours up to 30 days
    when 2520...43200     then locale.t :x_days,         count: (distance_in_minutes.to_f / 1440.0).round
      # 30 days up to 60 days
    when 43200...86400    then locale.t :about_x_months, count: (distance_in_minutes.to_f / 43200.0).round
      # 60 days up to 365 days
    when 86400...525600   then locale.t :x_months,       count: (distance_in_minutes.to_f / 43200.0).round
    else
      from_year = from_time.year
      from_year += 1 if from_time.month >= 3
      to_year = to_time.year
      to_year -= 1 if to_time.month < 3
      leap_years = (from_year > to_year) ? 0 : (from_year..to_year).count { |x| Date.leap?(x) }
      minute_offset_for_leap_year = leap_years * 1440
      # Discount the leap year days when calculating year distance.
      # e.g. if there are 20 leap year days between 2 dates having the same day
      # and month then based on 365 days calculation
      # the distance in years will come out to over 80 years when in written
      # English it would read better as about 80 years.
      minutes_with_offset = distance_in_minutes - minute_offset_for_leap_year
      remainder                   = (minutes_with_offset % MINUTES_IN_YEAR)
      distance_in_years           = (minutes_with_offset.div MINUTES_IN_YEAR)
      if remainder < MINUTES_IN_QUARTER_YEAR
        locale.t(:about_x_years,  count: distance_in_years)
      elsif remainder < MINUTES_IN_THREE_QUARTERS_YEAR
        locale.t(:over_x_years,   count: distance_in_years)
      else
        locale.t(:almost_x_years, count: distance_in_years + 1)
      end
    end
  end
end

def normalize_distance_of_time_argument_to_time(value)
  if value.is_a?(Numeric)
    Time.at(value)
  elsif value.respond_to?(:to_time)
    value.to_time
  else
    raise ArgumentError, "#{value.inspect} can't be converted to a Time value"
  end
end

select_date(my_date, prompt: true) # generic prompts for all
select_date(my_date, prompt: { hour: true }) # generic prompt for hours
select_date(my_date, prompt: { day: 'Choose day', month: 'Choose month', year: 'Choose year' })
# Generates a date select with a custom prompt. Use prompt: true for generic prompts.

select_date(my_date, prefix: 'payday')
# prefixed with 'payday' rather than 'date'.
# Generates a date select that defaults to the datetime in my_date (six days after today)

select_date(my_date, date_separator: '/')
# which has fields separated by '/'.
# Generates a date select that defaults to the date in my_date,

select_date(my_date, discard_type: true)
# my_date (six days after today).
# Generates a date select that discards the type of the field and defaults to the date in

select_date(my_date, order: [:year, :month, :day])
# with the fields ordered year, month, day rather than month, day, year.
# Generates a date select that defaults to the date in my_date (six days after today)

select_date()
# Generates a date select that defaults to today (no specified date).

select_date(my_date)
# Generates a date select that defaults to the date in my_date (six days after today).

my_date = Time.now + 6.days

If anything is passed in the html_options hash it will be applied to every select tag in the set.

If the array passed to the :order option does not contain all the three symbols, all tags will be hidden.
symbols :year, :month and :day in the desired order.
It's possible to explicitly set the order of the tags using the :order option with an array of
Returns a set of HTML select-tags (one for year, month, and day) pre-selected with the +date+.

def select_date(date = Date.current, options = {}, html_options = {})
  DateTimeSelector.new(date, options, html_options).select_date
end

select_datetime(my_date_time, prompt: true) # generic prompts for all
select_datetime(my_date_time, prompt: { hour: true }) # generic prompt for hours
select_datetime(my_date_time, prompt: { day: 'Choose day', month: 'Choose month', year: 'Choose year' })
# Generates a datetime select with a custom prompt. Use prompt: true for generic prompts.

select_datetime(my_date_time, prefix: 'payday')
# prefixed with 'payday' rather than 'date'
# Generates a datetime select that defaults to the datetime in my_date_time (four days after today)

select_datetime(my_date_time, ampm: true)
# Generate a datetime field with hours in the AM/PM format

select_datetime(my_date_time, discard_type: true)
# my_date_time (four days after today)
# Generates a datetime select that discards the type of the field and defaults to the datetime in

select_datetime(my_date_time, date_separator: '/', time_separator: '', datetime_separator: ',')
# separated by a comma (',').
# with a date fields separated by '/', time fields separated by '' and the date and time fields
# Generates a datetime select that defaults to the datetime in my_date_time (four days after today)

select_datetime(my_date_time, date_separator: '/')
# with a '/' between each date field.
# Generates a datetime select that defaults to the datetime in my_date_time (four days after today)

select_datetime(my_date_time, order: [:year, :month, :day])
# with the fields ordered year, month, day rather than month, day, year.
# Generates a datetime select that defaults to the datetime in my_date_time (four days after today)

select_datetime()
# Generates a datetime select that defaults to today (no specified datetime)

select_datetime(my_date_time)
# Generates a datetime select that defaults to the datetime in my_date_time (four days after today).

my_date_time = Time.now + 4.days

If anything is passed in the html_options hash it will be applied to every select tag in the set.

control visual display of the elements.
:date_separator, :datetime_separator and :time_separator keys to the +options+ to
supply a Symbol, it will be appended onto the :order passed in. You can also add
an array of symbols :year, :month and :day in the desired order. If you do not
+datetime+. It's also possible to explicitly set the order of the tags using the :order option with
Returns a set of HTML select-tags (one for year, month, day, hour, minute, and second) pre-selected with the

def select_datetime(datetime = Time.current, options = {}, html_options = {})
  DateTimeSelector.new(datetime, options, html_options).select_datetime
end

select_day(5, prompt: 'Choose day')
# generic prompt.
# Generates a select field for days with a custom prompt. Use prompt: true for a

select_day(my_date, field_name: 'due')
# that is named 'due' rather than 'day'.
# Generates a select field for days that defaults to the day for the date in my_date

select_day(5, use_two_digit_numbers: true)
# Generates a select field for days that defaults to the number given, but displays it with two digits.

select_day(5)
# Generates a select field for days that defaults to the number given.

select_day(my_date)
# Generates a select field for days that defaults to the day for the date in my_date.

my_date = Time.now + 2.days

Override the field name using the :field_name option, 'day' by default.
If you want to display days with a leading zero set the :use_two_digit_numbers key in +options+ to true.
The date can also be substituted for a day number.
Returns a select tag with options for each of the days 1 through 31 with the current day selected.

def select_day(date, options = {}, html_options = {})
  DateTimeSelector.new(date, options, html_options).select_day
end

select_hour(my_time, start_hour: 2, end_hour: 14)
# Generates a select field that includes options for hours from 2 to 14.

select_hour(my_time, ampm: true)
# Generate a select field for hours in the AM/PM format

select_hour(13, prompt: 'Choose hour')
# generic prompt.
# Generates a select field for hours with a custom prompt. Use prompt: true for a

select_hour(my_time, field_name: 'stride')
# that is named 'stride' rather than 'hour'.
# Generates a select field for hours that defaults to the hour for the time in my_time

select_hour(13)
# Generates a select field for hours that defaults to the number given.

select_hour(my_time)
# Generates a select field for hours that defaults to the hour for the time in my_time.

my_time = Time.now + 6.hours

Override the field name using the :field_name option, 'hour' by default.
The datetime can be either a +Time+ or +DateTime+ object or an integer.
Returns a select tag with options for each of the hours 0 through 23 with the current hour selected.

def select_hour(datetime, options = {}, html_options = {})
  DateTimeSelector.new(datetime, options, html_options).select_hour
end

select_minute(14, prompt: 'Choose minutes')
# generic prompt.
# Generates a select field for minutes with a custom prompt. Use prompt: true for a

select_minute(my_time, field_name: 'moment')
# that is named 'moment' rather than 'minute'.
# Generates a select field for minutes that defaults to the minutes for the time in my_time

select_minute(14)
# Generates a select field for minutes that defaults to the number given.

select_minute(my_time)
# Generates a select field for minutes that defaults to the minutes for the time in my_time.

my_time = Time.now + 10.minutes

Override the field name using the :field_name option, 'minute' by default.
selected. The datetime can be either a +Time+ or +DateTime+ object or an integer.
Also can return a select tag with options by minute_step from 0 through 59 with the 00 minute
Returns a select tag with options for each of the minutes 0 through 59 with the current minute selected.

def select_minute(datetime, options = {}, html_options = {})
  DateTimeSelector.new(datetime, options, html_options).select_minute
end

select_month(14, prompt: 'Choose month')
# generic prompt.
# Generates a select field for months with a custom prompt. Use prompt: true for a

select_month(Date.today, use_two_digit_numbers: true)
# will use keys with two digit numbers like "01", "03".
# Generates a select field for months that defaults to the current month that

select_month(Date.today, use_month_names: %w(Januar Februar Marts ...))
# will use keys like "Januar", "Marts."
# Generates a select field for months that defaults to the current month that

select_month(Date.today, use_short_month: true)
# will use keys like "Jan", "Mar".
# Generates a select field for months that defaults to the current month that

select_month(Date.today, add_month_numbers: true)
# will use keys like "1 - January", "3 - March".
# Generates a select field for months that defaults to the current month that

select_month(Date.today, use_month_numbers: true)
# will use keys like "1", "3".
# Generates a select field for months that defaults to the current month that

select_month(Date.today, field_name: 'start')
# is named "start" rather than "month".
# Generates a select field for months that defaults to the current month that

select_month(Date.today)
# will use keys like "January", "March".
# Generates a select field for months that defaults to the current month that

Override the field name using the :field_name option, 'month' by default.
If you want to display months with a leading zero set the :use_two_digit_numbers key in +options+ to true.
to use your own month names, set the :use_month_names key in +options+ to an array of 12 month names.
to show month names as abbreviations, set the :use_short_month key in +options+ to true. If you want
want both numbers and names, set the :add_month_numbers key in +options+ to true. If you would prefer
instead of names -- set the :use_month_numbers key in +options+ to true for this to happen. If you
used as values (what's submitted to the server). It's also possible to use month numbers for the presentation
selected. The month names are presented as keys (what's shown to the user) and the month numbers (1-12) are
Returns a select tag with options for each of the months January through December with the current month

def select_month(date, options = {}, html_options = {})
  DateTimeSelector.new(date, options, html_options).select_month
end

select_second(14, prompt: 'Choose seconds')
# generic prompt.
# Generates a select field for seconds with a custom prompt. Use prompt: true for a

select_second(my_time, field_name: 'interval')
# that is named 'interval' rather than 'second'.
# Generates a select field for seconds that defaults to the seconds for the time in my_time

select_second(33)
# Generates a select field for seconds that defaults to the number given.

select_second(my_time)
# Generates a select field for seconds that defaults to the seconds for the time in my_time.

my_time = Time.now + 16.seconds

Override the field name using the :field_name option, 'second' by default.
The datetime can be either a +Time+ or +DateTime+ object or an integer.
Returns a select tag with options for each of the seconds 0 through 59 with the current second selected.

def select_second(datetime, options = {}, html_options = {})
  DateTimeSelector.new(datetime, options, html_options).select_second
end

select_time(my_time, prompt: true) # generic prompts for all
select_time(my_time, prompt: { hour: true }) # generic prompt for hours
select_time(my_time, prompt: { day: 'Choose day', month: 'Choose month', year: 'Choose year' })
# Generates a time select with a custom prompt. Use :prompt to true for generic prompts.

select_time(my_time, start_hour: 2, end_hour: 14)
# Generates a time select field with hours that range from 2 to 14

select_time(my_time, ampm: true)
# Generate a time select field with hours in the AM/PM format

select_time(my_time, time_separator: ':', include_seconds: true)
# separated by ':' and includes an input for seconds.
# Generates a time select that defaults to the time in my_time, that has fields

select_time(my_time, include_seconds: true)
# that also includes an input for seconds.
# Generates a time select that defaults to the time in my_time,

select_time(my_time, time_separator: ':')
# which has fields separated by ':'.
# Generates a time select that defaults to the time in my_time,

select_time()
# Generates a time select that defaults to the current time (no specified time).

select_time(my_time)
# Generates a time select that defaults to the time in my_time.

my_time = Time.now + 5.days + 7.hours + 3.minutes + 14.seconds

If anything is passed in the html_options hash it will be applied to every select tag in the set.

the :include_seconds option to include an input for seconds.
You can set :time_separator key to format the output, and
Returns a set of HTML select-tags (one for hour and minute).

def select_time(datetime = Time.current, options = {}, html_options = {})
  DateTimeSelector.new(datetime, options, html_options).select_time
end

select_year(14, prompt: 'Choose year')
# generic prompt.
# Generates a select field for years with a custom prompt. Use prompt: true for a

select_year(2006, start_year: 2000, end_year: 2010)
# has ascending year values.
# Generates a select field for years that defaults to the year 2006 that

select_year(Date.today, start_year: 2005, end_year: 1900)
# has descending year values.
# Generates a select field for years that defaults to the current year that

select_year(Date.today, field_name: 'birth')
# is named 'birth' rather than 'year'.
# Generates a select field for years that defaults to the current year that

select_year(Date.today, start_year: 1992, end_year: 2007)
# has ascending year values.
# Generates a select field for years that defaults to the current year that

Override the field name using the :field_name option, 'year' by default.
greater than :end_year. The date can also be substituted for a year given as a number.
+options+. Both ascending and descending year lists are supported by making :start_year less than or
The five year radius can be changed using the :start_year and :end_year keys in the
Returns a select tag with options for each of the five years on each side of the current, which is selected.

def select_year(date, options = {}, html_options = {})
  DateTimeSelector.new(date, options, html_options).select_year
end

Note that you cannot pass a Numeric value to time_ago_in_words.

time_ago_in_words(from_time) # => 3 days
from_time = (3.days + 14.minutes + 25.seconds).ago

time_ago_in_words(from_time) # => 3 days
from_time = Time.now - 3.days - 14.minutes - 25.seconds

time_ago_in_words(Time.now, include_seconds: true) # => less than 5 seconds
time_ago_in_words(Time.now) # => less than a minute
time_ago_in_words(Time.now - 15.hours) # => about 15 hours
time_ago_in_words(3.minutes.ago) # => 3 minutes
time_ago_in_words(3.minutes.from_now) # => 3 minutes

Like distance_of_time_in_words, but where to_time is fixed to Time.now.

def time_ago_in_words(from_time, options = {})
  distance_of_time_in_words(from_time, Time.now, options)
end

all month choices are valid.
Note: If the day is not included as an option but the month is, the day will be set to the 1st to ensure that

The selects are prepared for multi-parameter assignment to an Active Record object.

time_select 'game', 'game_time', { ampm: true }
# You can set :ampm option to true which will show the hours as: 12 PM, 01 AM .. 11 PM.

time_select("article", "written_on", prompt: true) # generic prompts for all
time_select("article", "written_on", prompt: { hour: true }) # generic prompt for hours
time_select("article", "written_on", prompt: { hour: 'Choose hour', minute: 'Choose minute', second: 'Choose seconds' })
# Creates a time select tag with a custom prompt. Use prompt: true for generic prompts.

time_select 'game', 'game_time', { minute_step: 15 }
# You can set the :minute_step to 15 which will give you: 00, 15, 30, and 45.

time_select("article", "start_time", include_seconds: true)
# the sunrise attribute.
# Creates a time select tag with a seconds field that, when POSTed, will be stored in the article variables in

time_select("article", "sunrise")
# Creates a time select tag that, when POSTed, will be stored in the article variable in the sunrise attribute.

If anything is passed in the html_options hash it will be applied to every select tag in the set.

+date_select+ on the same method within the form otherwise an exception will be raised.
:ignore_date is set to +true+. If you set the :ignore_date to +true+, you must have a
This method will also generate 3 input hidden tags, for the actual year, month, and day unless the option

with :ampm option.
+object+). You can include the seconds with :include_seconds. You can get hours in the AM/PM format
specified time-based attribute (identified by +method+) on an object assigned to the template (identified by
Returns a set of select tags (one for hour, minute, and optionally second) pre-selected for accessing a

def time_select(object_name, method, options = {}, html_options = {})
  Tags::TimeSelect.new(object_name, method, self, options, html_options).render
end

# => Right now
<% end %>
Right now
<%= time_tag Time.now do %>

November 04, 2010
time_tag Date.today, datetime: Date.today.strftime('%G-W%V') # =>
Yesterday
time_tag Date.yesterday, 'Yesterday' # =>
November 04, 2010 17:55
time_tag Time.now # =>
November 04, 2010
time_tag Date.today # =>

Returns an HTML time tag for the given date or time.

def time_tag(date_or_time, *args, &block)
  options  = args.extract_options!
  format   = options.delete(:format) || :long
  content  = args.first || I18n.l(date_or_time, format: format)
  content_tag("time", content, options.reverse_merge(datetime: date_or_time.iso8601), &block)
end